text
stringlengths 11
4.05M
|
|---|
/*
Package v1 contains the API definitions for version v1.
*/
package v1
|
package main
import (
"net/http"
"time"
"context"
"fmt"
"net"
"encoding/json"
)
type key int
const userIPKey key = 0
func getIPFromRequest(r *http.Request) (net.IP, error) {
host, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
return nil, err
}
userIP := net.ParseIP(host)
if userIP == nil {
return nil, fmt.Errorf("remote addr error , %s", r.RemoteAddr)
}
return userIP, nil
}
func NewContextWithIP(ctx context.Context, userIP net.IP) context.Context {
return context.WithValue(ctx, userIPKey, userIP)
}
type result struct {
Timestamp string `json:"timestamp"`
Expire string `json:"expire"`
Scheme string `json:"scheme"`
ImageUrl string `json:"image_url"`
}
const API string = "http://api.suiyueyule.com/1.0.2/config/splash"
func search(ctx context.Context, query string) (result, error) {
var result result
req, err := http.NewRequest(http.MethodGet, API, nil)
if err != nil {
return result, err
}
q := req.URL.Query();
if userIP, err := ctx.Value(userIPKey).(net.IP); err {
q.Set("userip", userIP.String())
}
q.Set("q", query)
req.URL.RawQuery = q.Encode()
err = doRequest(ctx, req, func(response *http.Response, err error) error {
if err != nil {
return nil
}
defer response.Body.Close()
var data struct {
Status int `json:"status"`
Msg string `json:"msg"`
Data struct {
Timestamp string `json:"timestamp"`
Expire string `json:"expire"`
Scheme string `json:"scheme"`
ImageUrl string `json:"image_url"`
}
}
if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
return err
}
fmt.Println(data.Data)
return nil
})
return result, err
}
func doRequest(ctx context.Context, r *http.Request, f func(*http.Response, error) error) error {
tr := &http.Transport{}
client := &http.Client{Transport: tr }
c := make(chan error, 1)
go func() {
c <- f(client.Do(r))
}()
select {
case <-ctx.Done():
fmt.Println("优先ctx.done")
tr.CancelRequest(r)
<-c
return ctx.Err()
case err := <-c:
fmt.Println("优先result")
return err
}
}
func handleSearch(w http.ResponseWriter, r *http.Request) {
var (
ctx context.Context
cancel context.CancelFunc
)
ctx, cancel = context.WithTimeout(context.Background(), time.Millisecond*50)
/*
timeout, err := time.ParseDuration(r.FormValue("timeout"))
if err != nil {
fmt.Println(r.FormValue("timeout"))
ctx, cancel = context.WithTimeout(context.Background(), time.Millisecond * 50 )
} else {
ctx, cancel = context.WithCancel(context.Background())
}
*/
defer cancel()
query := r.FormValue("q")
if query == "" {
http.Error(w, "no query", http.StatusNotAcceptable)
return
}
userIP, err := getIPFromRequest(r)
ctx = NewContextWithIP(ctx, userIP)
start := time.Now()
result, err := search(ctx, query)
fmt.Println(result, err, start);
fmt.Fprint(w, err)
}
func main() {
http.HandleFunc("/search", handleSearch)
http.ListenAndServe(":9988", nil)
}
|
package db
import (
"context"
"database/sql"
"encoding/json"
"errors"
"time"
"github.com/google/uuid"
"github.com/jinzhu/gorm"
)
type File struct {
ID string `json:"id",sql:"type:uuid; primary key"`
UserID string `json:"user_id",sql:"type:uuid; foreign key"`
CreatedAt *time.Time `json:"created_at,omitempty",sql:"type:timestamp"`
LastModifiedAt *time.Time `json:"last_modified_at,omitempty",sql:"type:timestamp"`
Name string `json:"name,omitempty",sql:"type:VARCHAR(45)"`
Type FileType `json:"type,omitempty",sql:"type:ENUM('mortgage', 'contracting', 'property', 'receipts', 'repairs', 'taxes', 'other')"`
Year int `json:"year,omitempty",sql:"type:integer"`
SizeKB int `json:"size_kb,omitempty",sql:"type:integer"`
// Path is the path to our file within our GCS bucket.
Path string `json:"path,omitempty",sql:"varchar(255)"`
// Metadata contains information about the uploaded file.
Metadata json.RawMessage `json:"metadata,omitempty",sql:"type:JSONB"`
}
type FileType string
const (
Other FileType = "Other"
)
func (handle *Handle) AddFile(ctx context.Context, userID string, file *File, propertyIDs []string, addFileToCloudStorage func(ctx context.Context) error) error {
if file == nil {
return errors.New("nil file")
}
return handle.DB.Transaction(func(tx *gorm.DB) error {
if err := tx.FirstOrCreate(&file, file).Error; err != nil {
return err
}
// If there are property IDs to associate with this file, we need to create a reference to it.
for _, propertyID := range propertyIDs {
propertyID := propertyID
if propertyID == "" {
continue
}
propertyReference := PropertiesReferences{
UserID: userID,
PropertyID: sql.NullString{
String: propertyID,
Valid: true,
},
FileID: sql.NullString{
String: file.ID,
Valid: true,
},
ExpenseID: sql.NullString{},
}
if err := tx.FirstOrCreate(&propertyReference, propertyReference).Error; err != nil {
return err
}
}
if err := addFileToCloudStorage(ctx); err != nil {
return err
}
return nil
})
}
func (handle *Handle) GetFileById(userID, fileID string) (*File, error) {
_, err := uuid.Parse(userID)
if err != nil {
return nil, err
}
_, err = uuid.Parse(fileID)
if err != nil {
return nil, err
}
file := File{}
if err := handle.DB.Where("user_id = ? AND id = ?", userID, fileID).Find(&file).Error; err != nil {
return nil, err
}
return &file, nil
}
type FilesSummary struct {
TotalFiles int `json:"total_files,omitempty",sql:"type:integer"`
FilesTotalSize int `json:"files_total_size,omitempty",sql:"type:integer"`
}
// GetFilesSummaryByUserID will return a summary of a user's currently uploaded
// files. This is so we can display to users what their current file usage is.
func (handle *Handle) GetFilesSummaryByUserID(userID string) (*FilesSummary, error) {
_, err := uuid.Parse(userID)
if err != nil {
return nil, err
}
var filesSummary FilesSummary
if err := handle.DB.Select("COUNT(*) AS total_files, SUM(size_kb) AS files_total_size").Where("user_id = ?", userID).Table("files").Find(&filesSummary).Error; err != nil {
return nil, err
}
return &filesSummary, nil
}
// GetAllFiles will return all files for a user.
func (handle *Handle) GetAllFiles(userID string) ([]*File, error) {
_, err := uuid.Parse(userID)
if err != nil {
return nil, err
}
// We may need to filter by year if there are too many files.
var files []*File
if err := handle.DB.Where("user_id = ?", userID).Find(&files).Error; err != nil {
return nil, err
}
return files, nil
}
func (handle *Handle) GetFilesByProperty(userID, propertyID string) ([]*File, error) {
_, err := uuid.Parse(userID)
if err != nil {
return nil, err
}
_, err = uuid.Parse(propertyID)
if err != nil {
return nil, err
}
// We need to first query our properties_references table to find which properties have which files.
var propertyReferences []*PropertiesReferences
if err := handle.DB.Where("user_id = ? AND property_id = ? AND file_id IS NOT NULL", userID, propertyID).Find(&propertyReferences).Error; err != nil {
return nil, err
}
var filesIDs []string
for _, propertyReference := range propertyReferences {
fileID := propertyReference.FileID.String
if fileID != "" {
filesIDs = append(filesIDs, fileID)
}
}
if len(filesIDs) == 0 {
return nil, nil
}
// We may need to filter by year if there are too many files.
var files []*File
if err := handle.DB.Where("id IN (?)", filesIDs).Find(&files).Error; err != nil {
return nil, err
}
return files, nil
}
func (handle *Handle) DeleteFileByID(ctx context.Context, userID, fileID string, deleteFileFromCloudstorage func(ctx context.Context, filePath string) error) error {
_, err := uuid.Parse(userID)
if err != nil {
return err
}
_, err = uuid.Parse(fileID)
if err != nil {
return err
}
var file File
// We need to fetch the path first of the file.
if err := handle.DB.Select("path").Where("id = ? AND user_id = ?", fileID, userID).Find(&file).Error; err != nil {
return err
}
return handle.DB.Transaction(func(tx *gorm.DB) error {
filePath := file.Path
var propertyReferences PropertiesReferences
// Need to delete file from properties_references if linked to an expense.
if err := tx.Where("file_id = ? AND user_id = ?", fileID, userID).Delete(&propertyReferences).Error; err != nil {
if !errors.Is(err, gorm.ErrRecordNotFound) {
return err
}
}
if err := tx.Where("id = ? AND user_id = ?", fileID, userID).Delete(&file).Error; err != nil {
if !errors.Is(err, gorm.ErrRecordNotFound) {
return err
}
}
// We _must_ delete from cloudstorage last, because there is no way to rollback cloudstorage operations.
if filePath != "" {
if err := deleteFileFromCloudstorage(ctx, filePath); err != nil {
return err
}
}
return nil
})
}
|
package logger
import (
"fmt"
"chapter7/logger/logger"
)
func createLogger() *Logger {
l := NewLogger()
cw := newConsoleWriter()
l.RegisterWriter(cw)
// 创建文件写入器
fw := newFileWriter()
// 设置文件名称
if err := fw.SetFile("log.log"); err != nil {
fmt.Println(err)
}
l.RegisterWriter(fw)
return l
}
func main() {
l := createLogger()
l.Log("hello")
}
|
package orderedmap
import (
"strconv"
"testing"
"github.com/stretchr/testify/require"
)
type keyable int
func (k keyable) Key() string {
return strconv.Itoa(int(k))
}
func TestAdd(t *testing.T) {
om := New()
require.NotNil(t, om)
err := om.Add(keyable(1))
require.Nil(t, err)
require.Equal(t, om.Len(), 1)
err = om.Add(keyable(1))
require.NotNil(t, err)
require.Equal(t, om.Len(), 1)
}
func TestInsert(t *testing.T) {
om := New()
require.NotNil(t, om)
for i := 0; i < 100; i++ {
v := keyable(i)
err := om.Add(v)
require.Nil(t, err, "test case [%d] failed", i)
require.Equal(t, om.Len(), i+1)
}
// insert middle
v1 := keyable(500)
err := om.Insert(v1, 50)
require.Nil(t, err, "failed to insert")
require.Equal(t, om.Len(), 101)
v2 := om.GetByIndex(50)
require.Equal(t, v1, v2)
// insert top
v1 = keyable(501)
err = om.Insert(v1, 0)
require.Nil(t, err, "failed to insert")
require.Equal(t, om.Len(), 102)
v2 = om.GetByIndex(0)
require.Equal(t, v1, v2)
// insert tail
v1 = keyable(502)
err = om.Insert(v1, om.Len())
require.Nil(t, err, "failed to insert")
require.Equal(t, om.Len(), 103)
v2 = om.GetByIndex(om.Len() - 1)
require.Equal(t, v1, v2)
}
func TestSwap(t *testing.T) {
om := New()
require.NotNil(t, om)
v1 := keyable(1)
err := om.Add(v1)
require.Nil(t, err)
require.Equal(t, om.Len(), 1)
v2 := keyable(2)
err = om.Add(v2)
require.Nil(t, err)
require.Equal(t, om.Len(), 2)
om.Swap(0, 1)
require.Equal(t, om.GetByIndex(0), v2)
require.Equal(t, om.GetByIndex(1), v1)
require.Equal(t, om.Len(), 2)
}
func TestUpdate(t *testing.T) {
om := New()
require.NotNil(t, om)
err := om.Add(keyable(1))
require.Nil(t, err)
require.Equal(t, om.Len(), 1)
err = om.Update(keyable(1))
require.Nil(t, err)
require.Equal(t, om.Len(), 1)
err = om.Update(keyable(2))
require.NotNil(t, err)
require.Equal(t, om.Len(), 1)
}
func TestAddGet(t *testing.T) {
om := New()
require.NotNil(t, om)
for i := 0; i < 100; i++ {
v := keyable(i)
err := om.Add(v)
require.Nil(t, err, "test case [%d] failed", i)
require.Equal(t, om.Len(), i+1)
}
for i := 0; i < 100; i++ {
v := om.GetByIndex(i)
require.Equal(t, v, keyable(i), "test case [%d] failed", i)
}
for i := 0; i < 100; i++ {
v := om.GetByKey(strconv.Itoa(i))
require.Equal(t, v, keyable(i), "test case [%d] failed", i)
}
}
func TestRemoveByIndex(t *testing.T) {
om := New()
require.NotNil(t, om)
for i := 0; i < 100; i++ {
v := keyable(i)
err := om.Add(v)
require.Nil(t, err, "test case [%d] failed", i)
require.Equal(t, om.Len(), i+1)
}
require.Equal(t, 100, om.Len())
for i := 0; i < 100; i++ {
err := om.RemoveByIndex(0)
require.Nil(t, err, "test case [%d] failed", i)
require.Equal(t, 100-(i+1), om.Len(), "test case [%d] failed", i)
}
}
func TestRemoveByKey(t *testing.T) {
om := New()
require.NotNil(t, om)
for i := 0; i < 100; i++ {
v := keyable(i)
err := om.Add(v)
require.Nil(t, err, "test case [%d] failed", i)
require.Equal(t, om.Len(), i+1)
}
require.Equal(t, 100, om.Len())
for i := 0; i < 100; i++ {
err := om.RemoveByKey(strconv.Itoa(i))
require.Nil(t, err, "test case [%d] failed", i)
require.Equal(t, 100-(i+1), om.Len(), "test case [%d] failed", i)
}
}
func TestForEach(t *testing.T) {
om := New()
require.NotNil(t, om)
for i := 0; i < 100; i++ {
v := keyable(i)
err := om.Add(v)
require.Nil(t, err, "test case [%d] failed", i)
require.Equal(t, om.Len(), i+1)
}
om.ForEach(func(i int, v Keyer) error {
require.Equal(t, v, keyable(i), "test case [%d] failed", i)
return nil
})
}
|
// This file was generated for SObject CollaborationGroupMemberRequest, API Version v43.0 at 2018-07-30 03:47:37.763690275 -0400 EDT m=+24.107201280
package sobjects
import (
"fmt"
"strings"
)
type CollaborationGroupMemberRequest struct {
BaseSObject
CollaborationGroupId string `force:",omitempty"`
CreatedById string `force:",omitempty"`
CreatedDate string `force:",omitempty"`
Id string `force:",omitempty"`
LastModifiedById string `force:",omitempty"`
LastModifiedDate string `force:",omitempty"`
RequesterId string `force:",omitempty"`
ResponseMessage string `force:",omitempty"`
Status string `force:",omitempty"`
SystemModstamp string `force:",omitempty"`
}
func (t *CollaborationGroupMemberRequest) ApiName() string {
return "CollaborationGroupMemberRequest"
}
func (t *CollaborationGroupMemberRequest) String() string {
builder := strings.Builder{}
builder.WriteString(fmt.Sprintf("CollaborationGroupMemberRequest #%s - %s\n", t.Id, t.Name))
builder.WriteString(fmt.Sprintf("\tCollaborationGroupId: %v\n", t.CollaborationGroupId))
builder.WriteString(fmt.Sprintf("\tCreatedById: %v\n", t.CreatedById))
builder.WriteString(fmt.Sprintf("\tCreatedDate: %v\n", t.CreatedDate))
builder.WriteString(fmt.Sprintf("\tId: %v\n", t.Id))
builder.WriteString(fmt.Sprintf("\tLastModifiedById: %v\n", t.LastModifiedById))
builder.WriteString(fmt.Sprintf("\tLastModifiedDate: %v\n", t.LastModifiedDate))
builder.WriteString(fmt.Sprintf("\tRequesterId: %v\n", t.RequesterId))
builder.WriteString(fmt.Sprintf("\tResponseMessage: %v\n", t.ResponseMessage))
builder.WriteString(fmt.Sprintf("\tStatus: %v\n", t.Status))
builder.WriteString(fmt.Sprintf("\tSystemModstamp: %v\n", t.SystemModstamp))
return builder.String()
}
type CollaborationGroupMemberRequestQueryResponse struct {
BaseQuery
Records []CollaborationGroupMemberRequest `json:"Records" force:"records"`
}
|
package terraform_kintone
import (
"reflect"
"testing"
)
func TestFieldSchemaMapper(t *testing.T) {
testCases := []struct {
title string
fieldMap map[string]interface{}
shouldBeError bool
}{
{
title: "SINGLE_LINE_TEXT",
fieldMap: map[string]interface{}{
"type": "SINGLE_LINE_TEXT",
"code": "text-1",
"label": "🍣🍺",
},
},
{
title: "MULTI_LINE_TEXT",
fieldMap: map[string]interface{}{
"type": "MULTI_LINE_TEXT",
"code": "text-2",
"label": "🍣🍺",
},
},
{
title: "NUMBER",
fieldMap: map[string]interface{}{
"type": "NUMBER",
"code": "number-1",
"label": "🍣🍺",
},
},
{
title: "Unknown type",
fieldMap: map[string]interface{}{
"type": "ABCDEFG",
"code": "xxx-1",
"label": "🍣🍺",
},
shouldBeError: true,
},
}
for _, tt := range testCases {
t.Run(tt.title, func(t *testing.T) {
mapper := fieldSchemaMapper{}
f, err := mapper.SchemaToField(tt.fieldMap)
if tt.shouldBeError {
if err == nil {
t.Fatalf("expected: error, actual: no errors")
}
return
}
if err != nil {
t.Fatalf("error: %+v", err)
}
fieldMap := mapper.FieldToSchema(f)
if !reflect.DeepEqual(fieldMap, tt.fieldMap) {
t.Fatalf("fieldMap != tt.fieldMap: fieldMap=%+v, tt.fieldMap=%+v", fieldMap, tt.fieldMap)
}
})
}
}
|
package main
import (
"errors"
"flag"
"fmt"
logs "github.com/sirupsen/logrus"
"github.com/yangqinjiang/mycrontab/master/lib"
"os"
"runtime"
"time"
)
var (
help bool
quiet bool //日志安静模式,不输出info级别的日志
confFile string //配置文件的路径
version bool
)
var version_str string = "1.0"
//解析命令行参数
//TODO:在 goland IDE里启动,需要替换working directory
///src/github.com/yangqinjiang/mycrontab/crontab/master/main
func initFlag() {
flag.BoolVar(&help, "h", false, "help ,github code source => https://github.com/yangqinjiang/mycrontab ")
flag.StringVar(&confFile, "c", "./config/master.json", "指定master.json")
flag.BoolVar(&quiet, "q", false, "quiet,Only log the warning severity or above.")
flag.BoolVar(&version, "v", false, "Print version infomation and quit")
flag.Usage = usage
}
func usage() {
fmt.Fprintf(os.Stderr, fmt.Sprintf(`mycrontab master version: %s
Usage: master [-hqv] [-c filename]
Options:
`, version_str))
flag.PrintDefaults()
}
//初始化logs的配置
func initLogs(env_production bool) {
// do something here to set environment depending on an environment variable
// or command-line flag
if env_production {
//日志打印 代码调用的路径
logs.SetReportCaller(true)
logs.SetFormatter(&logs.JSONFormatter{})
} else {
// The TextFormatter is default, you don't actually have to do this.
logs.SetFormatter(&logs.TextFormatter{})
}
//安静模式,只输出warn及以上的日志
if quiet {
// Only log the warning severity or above.
logs.SetLevel(logs.WarnLevel)
}
}
func InitEnv() {
//线程数==CPU数量
runtime.GOMAXPROCS(runtime.NumCPU())
}
func init() {
//初始化命令行参数
initFlag()
}
func main() {
flag.Parse()
//版本信息
if version {
showVersion()
return
}
//帮助文档
if help {
flag.Usage()
return
}
var (
err error
)
//初始化线程
InitEnv()
//加载配置
err = lib.InitConfig(confFile)
if err != nil {
goto ERR
}
initLogs(lib.G_config.LogsProduction)
logs.Info("Crontab Master Running...")
logs.Info("读取配置文件[成功]")
//启动任务管理器
err = lib.InitJobMgr()
if err != nil {
goto ERR
}
if nil == lib.G_jobMgr {
err = errors.New(" 连接 ETCD 数据库出错,初始化 LogMgr实例 [失败]")
goto ERR
}
logs.Info("启动任务管理器[成功]")
//启动日志管理器
err = lib.InitLogMgr()
if err != nil {
goto ERR
}
if nil == lib.G_jobMgr {
err = errors.New(" 连接 mongodb 数据库出错,初始化 G_logMgr 实例 [失败]")
goto ERR
}
logs.Info("启动日志管理器[成功]")
//启动服务发现
err = lib.InitWorkerMgr()
if err != nil {
goto ERR
}
if nil == lib.G_workerMgr {
err = errors.New(" 连接 ETCD 数据库出错,初始化 G_workerMgr 实例 [失败]")
goto ERR
}
logs.Info("启动服务发现[成功]")
//启动Api Http服务
err = lib.InitApiServer()
if err != nil {
goto ERR //启动出错,直接跳出
}
logs.Info("启动Api Http服务[成功]\nMaster启动完成.正常待机")
//休息一秒
for {
time.Sleep(1 * time.Second)
}
return
//异常退出
ERR:
logs.Error("Master启动失败:" + err.Error())
}
func showVersion() {
fmt.Println(fmt.Sprintf("v%s", version_str))
}
|
// Copyright 2019 PingCAP, Inc.
//
// 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 executor
import (
"context"
"strings"
"github.com/pingcap/errors"
"github.com/pingcap/tidb/executor/internal/exec"
"github.com/pingcap/tidb/parser"
"github.com/pingcap/tidb/parser/ast"
"github.com/pingcap/tidb/planner/core"
"github.com/pingcap/tidb/sessionctx"
"github.com/pingcap/tidb/util"
"github.com/pingcap/tidb/util/chunk"
)
// IndexAdviseExec represents a index advise executor.
type IndexAdviseExec struct {
exec.BaseExecutor
IsLocal bool
indexAdviseInfo *IndexAdviseInfo
}
// Next implements the Executor Next interface.
func (e *IndexAdviseExec) Next(context.Context, *chunk.Chunk) error {
if !e.IsLocal {
return errors.New("Index Advise: don't support load file without local field")
}
if e.indexAdviseInfo.Path == "" {
return errors.New("Index Advise: infile path is empty")
}
if len(e.indexAdviseInfo.LinesTerminatedBy) == 0 {
return errors.New("Index Advise: don't support advise index for SQL terminated by nil")
}
if val := e.Ctx().Value(IndexAdviseVarKey); val != nil {
e.Ctx().SetValue(IndexAdviseVarKey, nil)
return errors.New("Index Advise: previous index advise option isn't closed normally")
}
e.Ctx().SetValue(IndexAdviseVarKey, e.indexAdviseInfo)
return nil
}
// Close implements the Executor Close interface.
func (*IndexAdviseExec) Close() error {
return nil
}
// Open implements the Executor Open interface.
func (*IndexAdviseExec) Open(context.Context) error {
return nil
}
// IndexAdviseInfo saves the information of index advise operation.
type IndexAdviseInfo struct {
Path string
MaxMinutes uint64
MaxIndexNum *ast.MaxIndexNumClause
core.LineFieldsInfo
Ctx sessionctx.Context
StmtNodes [][]ast.StmtNode
Result *IndexAdvice
}
func (e *IndexAdviseInfo) getStmtNodes(data []byte) error {
str := string(data)
sqls := strings.Split(str, e.LinesTerminatedBy)
j := 0
for i, sql := range sqls {
if sql != "\n" && sql != "" && strings.HasPrefix(sql, e.LinesStartingBy) {
sqls[j] = sqls[i]
j++
}
}
sqls = sqls[:j]
sv := e.Ctx.GetSessionVars()
e.StmtNodes = make([][]ast.StmtNode, len(sqls))
sqlParser := parser.New()
for i, sql := range sqls {
stmtNodes, warns, err := sqlParser.ParseSQL(sql)
if err != nil {
return err
}
for _, warn := range warns {
sv.StmtCtx.AppendWarning(util.SyntaxWarn(warn))
}
curStmtNodes := make([]ast.StmtNode, len(stmtNodes))
copy(curStmtNodes, stmtNodes)
e.StmtNodes[i] = curStmtNodes
}
return nil
}
func (e *IndexAdviseInfo) prepareInfo(data []byte) error {
if e.MaxMinutes == 0 {
return errors.New("Index Advise: the maximum execution time limit should be greater than 0")
}
if e.MaxIndexNum != nil {
if e.MaxIndexNum.PerTable == 0 || e.MaxIndexNum.PerDB == 0 {
return errors.New("Index Advise: the maximum number of indexes should be greater than 0")
}
}
return e.getStmtNodes(data)
}
// GetIndexAdvice gets the index advice by workload file.
func (e *IndexAdviseInfo) GetIndexAdvice(data []byte) error {
if err := e.prepareInfo(data); err != nil {
return err
}
// TODO: Finish the index advise process. It will be done in another PR.
return nil
}
// IndexAdvice represents the index advice.
type IndexAdvice struct {
// TODO: Define index advice data structure and implements the ResultSet interface. It will be done in another PR
}
// IndexAdviseVarKeyType is a dummy type to avoid naming collision in context.
type IndexAdviseVarKeyType int
// String defines a Stringer function for debugging and pretty printing.
func (IndexAdviseVarKeyType) String() string {
return "index_advise_var"
}
// IndexAdviseVarKey is a variable key for index advise.
const IndexAdviseVarKey IndexAdviseVarKeyType = 0
|
package calcstats
import "sync"
var Cnt int64
var lock = sync.Mutex{}
func Incr() {
lock.Lock()
Cnt++
lock.Unlock()
}
var Tpose int64
var tlock = sync.Mutex{}
func TposeIncr() {
tlock.Lock()
Tpose++
tlock.Unlock()
}
var Dots int64
var dlock = sync.Mutex{}
func Dot() {
dlock.Lock()
Dots++
dlock.Unlock()
}
var Crosses int64
var clock = sync.Mutex{}
func Cross() {
clock.Lock()
Crosses++
clock.Unlock()
}
var Ns int64
var nlock = sync.Mutex{}
func Normalize() {
nlock.Lock()
Ns++
nlock.Unlock()
}
|
package exportAsciinemaJson
import (
"encoding/json"
"github.com/stbuehler/go-termrecording/rawrecording"
"io"
)
func WriteHTML(writer io.Writer, terminalSize rawrecording.TerminalSize, snapshot *Frame, stdoutLocation string, totalTime float64) error {
stdoutLoc, err := json.Marshal(stdoutLocation)
if err != nil {
return err
}
if snapshot == nil {
snapshot = &Frame{
Lines: []Line{},
}
}
snapshotJson, err := json.Marshal(snapshot.Lines)
if err != nil {
return err
}
_, err = writer.Write([]byte(
`<html>
<head>
<link rel="stylesheet" type="text/css" href="https://stbuehler.github.io/asciinema-player/css/asciinema-player.css" />
<link rel="stylesheet" type="text/css" href="https://stbuehler.github.io/asciinema-player/css/themes/tango.css" />
<link rel="stylesheet" type="text/css" href="https://stbuehler.github.io/asciinema-player/css/themes/solarized-dark.css" />
<link rel="stylesheet" type="text/css" href="https://stbuehler.github.io/asciinema-player/css/themes/solarized-light.css" />
<script src="https://stbuehler.github.io/asciinema-player/vendor/react-0.10.0.js"></script>
<script src="https://stbuehler.github.io/asciinema-player/vendor/JSXTransformer-0.10.0.js"></script>
<script src="https://stbuehler.github.io/asciinema-player/vendor/jquery-1.10.0.min.js"></script>
<script src="https://stbuehler.github.io/asciinema-player/vendor/screenfull.js"></script>
<script src="https://stbuehler.github.io/asciinema-player/js/asciinema-player.min.js"></script>
</head>
<body>
<div id="player-container"></div>
<script>
React.renderComponent(
asciinema.Player({
autoPlay: false,
movie: new asciinema.Movie(
` + Stringify(terminalSize.Columns) + ", " + Stringify(terminalSize.Rows) + `,
new asciinema.HttpArraySource(` + string(stdoutLoc) + `, 1),
` + string(snapshotJson) + `,
` + Stringify(totalTime) + `
)
}),
document.getElementById('player-container')
);
</script>
</body>
</html>`))
return err
}
|
package fmm
import (
"strings"
)
// A small representation of a mod, with an optional version.
type ModIdent struct {
Name string
Version *Version
}
// Returns a ModIdent parsed from an input string with the format of 'name',
// 'name_version', or 'name_version.zip'.
func NewModIdent(input string) ModIdent {
input = strings.TrimSuffix(input, ".zip")
parts := strings.Split(input, "_")
if len(parts) == 1 {
return ModIdent{input, nil}
}
name := strings.Join(parts[:len(parts)-1], "_")
version, err := NewVersion(parts[len(parts)-1])
if err != nil {
return ModIdent{input, nil}
}
return ModIdent{name, version}
}
// Returns a string in the format of 'name' or 'name_version'.
func (i *ModIdent) ToString() string {
if i.Version != nil {
return i.Name + " " + i.Version.ToString(false)
}
return i.Name
}
|
package Geek
import "math"
func maximum(a int, b int) int {
highestBit := int(uint(a-b) >> 63)
return b*(highestBit) + a*(highestBit^1)
}
func maximum(a int, b int) int {
mid := float64(a+b)/2.0
distanceFromMidToAorB := math.Abs(float64(a)-mid)
return int(mid+distanceFromMidToAorB)
}
/*
题目链接:
1. 这题真Geek。
2. 我是看官方题解后才知道怎么写的，虽然知道要使用位运算..
*/
|
package main
import "fmt"
func main() {
//integers := []int{}
integers := make([]int, 0)
for i := 0; i < 11; i++ {
integers = append(integers, i)
}
for _, integer := range integers {
checkParity(integer)
}
}
func checkParity(i int) {
if i & 1 == 1 {
fmt.Println(i, "is odd")
} else {
fmt.Println(i, "is even")
}
}
|
package sort
import (
"fmt"
"testing"
)
func TestHeapSort(t *testing.T) {
heap := &Heap{data: []int{5, 7, 2, 5, 6, 8, 4, 13, 5, 6, 7}}
heap.Sort()
fmt.Println(heap.data)
}
|
package main
import (
"fmt"
"net/http"
"os"
"github.com/jonagold-lab/go-apptweak/apptweak"
)
type input struct {
appID int
markets []string
languages []string
devices []string
topCompetitorIds []int
topKeywords []string
topNegativeKeywords []string
}
func main() {
app := input{
appID: 1222530780,
markets: []string{"de"},
languages: []string{"de"},
devices: []string{"iphone"},
topCompetitorIds: []int{891535485, 654810212},
topKeywords: []string{
"hiit",
"freeletics",
"high intensity training",
"weightloss",
},
topNegativeKeywords: []string{},
}
options := apptweak.Options{
Country: app.markets[0],
Language: app.languages[0],
Device: app.devices[0],
}
token := os.Getenv("APPTWEAK_TOKEN")
hc := &http.Client{}
client := apptweak.NewAuthClient(token, hc)
resp, err := client.AppDetails(app.appID, options)
if err != nil {
if err.Error() == "Response Error" {
fmt.Printf("This is a %v", err)
}
fmt.Println("error:", err)
return
}
fmt.Println(resp.AD.Title)
}
|
package mpc
/*
#cgo LDFLAGS: -lm
#include "mpc_interface.h"
*/
import "C"
import (
"errors"
"unsafe"
)
type Ast *C.mpc_ast_t
type Error *C.mpc_err_t
type Parser *C.mpc_parser_t
func New(name string) Parser {
cName := C.CString(name)
defer C.free(unsafe.Pointer(cName))
return C.mpc_new(cName)
}
func Cleanup(p1, p2, p3, p4 Parser) {
C.mpc_cleanup_if(p1, p2, p3, p4)
}
func MpcaLang(language string, parsers ...Parser) {
cLanguage := C.CString(language)
defer C.free(unsafe.Pointer(cLanguage))
C.mpca_lang_if(C.MPCA_LANG_DEFAULT, cLanguage,
parsers[0], parsers[1], parsers[2], parsers[3])
}
func Parse(input string, parser Parser) (C.mpc_result_t, error) {
var r C.mpc_result_t
cInput := C.CString(input)
defer C.free(unsafe.Pointer(cInput))
stdin := C.CString("<stdin>")
defer C.free(unsafe.Pointer(stdin))
var err error
if C.mpc_parse(stdin, cInput, parser, &r) == C.int(0) {
err = errors.New("mpc: failed to parse input string")
}
return r, err
}
func GetOutput(result *C.mpc_result_t) Ast {
cast := (*Ast)(unsafe.Pointer(result))
return *cast
}
func GetError(result *C.mpc_result_t) Error {
cast := (*Error)(unsafe.Pointer(result))
return *cast
}
func ErrDelete(result *C.mpc_result_t) {
C.mpc_err_delete(GetError(result))
}
func ErrPrint(result *C.mpc_result_t) {
C.mpc_err_print(GetError(result))
}
func AstDelete(result *C.mpc_result_t) {
C.mpc_ast_delete(GetOutput(result))
}
// PrintAst parses an input string for its AST representation
func PrintAst(input string, parser Parser) {
r, err := Parse(input, parser)
if err != nil {
ErrPrint(&r)
ErrDelete(&r)
} else {
C.mpc_ast_print(GetOutput(&r))
AstDelete(&r)
}
}
|
package main
import (
"errors"
"fmt"
"os"
"path/filepath"
"github.com/google/hilbert"
"github.com/gitchander/go-lang/cairo"
"github.com/gitchander/go-lang/cairo/color"
)
type Size struct {
Width, Height int
}
func HilbertCurve(c *cairo.Canvas, n int, size Size) error {
s, err := hilbert.New(n)
if err != nil {
return err
}
var (
dX = float64(size.Width) / float64(s.N)
dY = float64(size.Height) / float64(s.N)
)
c.SetLineWidth(0.2 * ((dX + dY) / 2))
c.SetLineCap(cairo.LINE_CAP_ROUND)
c.SetLineJoin(cairo.LINE_JOIN_ROUND)
m := cairo.NewMatrix()
m.InitIdendity()
m.Scale(dX, dY)
m.Translate(0.5, 0.5)
if nn := s.N * s.N; nn > 0 {
x, y, _ := s.Map(0)
fX, fY := m.TransformPoint(float64(x), float64(y))
c.MoveTo(fX, fY)
for i := 1; i < nn; i++ {
x, y, _ = s.Map(i)
fX, fY = m.TransformPoint(float64(x), float64(y))
c.LineTo(fX, fY)
}
}
c.Stroke()
return nil
}
func drawCurve(c *cairo.Canvas, n int, size Size) error {
c.SetSourceRGB(0, 0, 0)
if err := HilbertCurve(c, n, size); err != nil {
return err
}
return nil
}
func drawDoubleCurve(c *cairo.Canvas, n int, size Size) error {
c.SetSourceRGB(0.2, 0, 0)
if err := HilbertCurve(c, n, size); err != nil {
return err
}
c.SetSourceRGB(0.8, 0, 0)
if err := HilbertCurve(c, n*2, size); err != nil {
return err
}
return nil
}
func makeHilbertPNG(fileName string, n int, size Size) error {
surface, err := cairo.NewSurface(cairo.FORMAT_ARGB32, size.Width, size.Height)
if err != nil {
return err
}
defer surface.Destroy()
canvas, err := cairo.NewCanvas(surface)
if err != nil {
return err
}
defer canvas.Destroy()
color.CanvasFillRGB(canvas, color.NewRGB(1.0, 1.0, 1.0))
err = drawCurve(canvas, n, size)
//err = drawDoubleCurve(canvas, n, size)
if err != nil {
return err
}
if err = surface.WriteToPNG(fileName); err != nil {
return err
}
return nil
}
func makeDir(dir string) error {
fi, err := os.Stat(dir)
if err != nil {
err = os.Mkdir(dir, os.ModePerm)
if err != nil {
return err
}
} else {
if !fi.IsDir() {
return errors.New("file is not dir")
}
}
return nil
}
func makeFiles() error {
dir := "./curves"
size := Size{512, 512}
if err := makeDir(dir); err != nil {
return err
}
p := 2
for i := 0; i < 9; i++ {
fileName := filepath.Join(dir, fmt.Sprintf("hilbert_curve_%d.png", p))
if err := makeHilbertPNG(fileName, p, size); err != nil {
return err
}
p *= 2
}
return nil
}
func main() {
if err := makeFiles(); err != nil {
fmt.Println(err.Error())
}
}
|
/*
Copyright 2011 The Camlistore 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 mongo implements the Camlistore index storage abstraction
// on top of MongoDB.
package mongo
import (
"errors"
"os"
"strconv"
"strings"
"sync"
"time"
"camlistore.org/pkg/blobserver"
"camlistore.org/pkg/index"
"camlistore.org/pkg/jsonconfig"
"camlistore.org/third_party/labix.org/v2/mgo"
"camlistore.org/third_party/labix.org/v2/mgo/bson"
)
// We explicitely separate the key and the value in a document,
// instead of simply storing as key:value, to avoid problems
// such as "." being an illegal char in a key name. Also because
// there is no way to do partial matching for key names (one can
// only check for their existence with bson.M{$exists: true}).
const (
collectionName = "keys"
mgoKey = "k"
mgoValue = "v"
)
type MongoWrapper struct {
Servers string
User string
Password string
Database string
Collection string
}
func (mgw *MongoWrapper) url() string {
if mgw.User == "" || mgw.Password == "" {
return mgw.Servers
}
return mgw.User + ":" + mgw.Password + "@" + mgw.Servers + "/" + mgw.Database
}
// Note that Ping won't work with old (1.2) mongo servers.
func (mgw *MongoWrapper) TestConnection(timeout time.Duration) bool {
session, err := mgo.DialWithTimeout(mgw.url(), timeout)
if err != nil {
return false
}
defer session.Close()
session.SetSyncTimeout(timeout)
if err = session.Ping(); err != nil {
return false
}
return true
}
func (mgw *MongoWrapper) getConnection() (*mgo.Session, error) {
// TODO(mpl): do some "client caching" as in mysql, to avoid systematically dialing?
session, err := mgo.Dial(mgw.url())
if err != nil {
return nil, err
}
session.SetMode(mgo.Monotonic, true)
session.SetSafe(&mgo.Safe{})
return session, nil
}
// TODO(mpl): I'm only calling getCollection at the beginning, and
// keeping the collection around and reusing it everywhere, instead
// of calling getCollection everytime, because that's the easiest.
// But I can easily change that. Gustavo says it does not make
// much difference either way.
// Brad, what do you think?
func (mgw *MongoWrapper) getCollection() (*mgo.Collection, error) {
session, err := mgw.getConnection()
if err != nil {
return nil, err
}
session.SetSafe(&mgo.Safe{})
session.SetMode(mgo.Strong, true)
c := session.DB(mgw.Database).C(mgw.Collection)
return c, nil
}
func init() {
blobserver.RegisterStorageConstructor("mongodbindexer",
blobserver.StorageConstructor(newMongoIndexFromConfig))
}
func newMongoIndex(mgw *MongoWrapper) (*index.Index, error) {
db, err := mgw.getCollection()
if err != nil {
return nil, err
}
mongoStorage := &mongoKeys{db: db}
return index.New(mongoStorage), nil
}
func newMongoIndexFromConfig(ld blobserver.Loader, config jsonconfig.Obj) (blobserver.Storage, error) {
blobPrefix := config.RequiredString("blobSource")
mgw := &MongoWrapper{
Servers: config.OptionalString("host", "localhost"),
Database: config.RequiredString("database"),
User: config.OptionalString("user", ""),
Password: config.OptionalString("password", ""),
Collection: collectionName,
}
if err := config.Validate(); err != nil {
return nil, err
}
sto, err := ld.GetStorage(blobPrefix)
if err != nil {
return nil, err
}
ix, err := newMongoIndex(mgw)
if err != nil {
return nil, err
}
ix.BlobSource = sto
// Good enough, for now:
ix.KeyFetcher = ix.BlobSource
if wipe, _ := strconv.ParseBool(os.Getenv("CAMLI_MONGO_WIPE")); wipe {
err = ix.Storage().Delete("")
if err != nil {
return nil, err
}
}
return ix, err
}
// Implementation of index Iterator
type mongoStrIterator struct {
res bson.M
*mgo.Iter
}
func (s mongoStrIterator) Next() bool {
return s.Iter.Next(&s.res)
}
func (s mongoStrIterator) Key() (key string) {
key, ok := (s.res[mgoKey]).(string)
if !ok {
return ""
}
return key
}
func (s mongoStrIterator) Value() (value string) {
value, ok := (s.res[mgoValue]).(string)
if !ok {
return ""
}
return value
}
func (s mongoStrIterator) Close() error {
// TODO(mpl): think about anything more to be done here.
return nil
}
// Implementation of index.Storage
type mongoKeys struct {
mu sync.Mutex // guards db
db *mgo.Collection
}
func (mk *mongoKeys) Get(key string) (string, error) {
mk.mu.Lock()
defer mk.mu.Unlock()
res := bson.M{}
q := mk.db.Find(&bson.M{mgoKey: key})
err := q.One(&res)
if err != nil {
if err == mgo.ErrNotFound {
return "", index.ErrNotFound
} else {
return "", err
}
}
return res[mgoValue].(string), err
}
func (mk *mongoKeys) Find(key string) index.Iterator {
mk.mu.Lock()
defer mk.mu.Unlock()
// TODO(mpl): escape other special chars, or maybe replace $regex with something
// more suited if possible.
cleanedKey := strings.Replace(key, "|", `\|`, -1)
iter := mk.db.Find(&bson.M{mgoKey: &bson.M{"$regex": "^" + cleanedKey}}).Sort(mgoKey).Iter()
return mongoStrIterator{res: bson.M{}, Iter: iter}
}
func (mk *mongoKeys) Set(key, value string) error {
mk.mu.Lock()
defer mk.mu.Unlock()
_, err := mk.db.Upsert(&bson.M{mgoKey: key}, &bson.M{mgoKey: key, mgoValue: value})
return err
}
// Delete removes the document with the matching key.
// If key is "", it removes all documents.
func (mk *mongoKeys) Delete(key string) error {
mk.mu.Lock()
defer mk.mu.Unlock()
if key == "" {
_, err := mk.db.RemoveAll(nil)
return err
}
return mk.db.Remove(&bson.M{mgoKey: key})
}
func (mk *mongoKeys) BeginBatch() index.BatchMutation {
return index.NewBatchMutation()
}
type batch interface {
Mutations() []index.Mutation
}
func (mk *mongoKeys) CommitBatch(bm index.BatchMutation) error {
b, ok := bm.(batch)
if !ok {
return errors.New("invalid batch type")
}
mk.mu.Lock()
defer mk.mu.Unlock()
for _, m := range b.Mutations() {
if m.IsDelete() {
if err := mk.db.Remove(bson.M{mgoKey: m.Key()}); err != nil {
return err
}
} else {
if _, err := mk.db.Upsert(&bson.M{mgoKey: m.Key()}, &bson.M{mgoKey: m.Key(), mgoValue: m.Value()}); err != nil {
return err
}
}
}
return nil
}
|
package stateful
import (
"context"
"fmt"
aliceapi "github.com/yandex-cloud/examples/serverless/alice-shareable-todolist/app/alice/api"
"github.com/yandex-cloud/examples/serverless/alice-shareable-todolist/app/errors"
"github.com/yandex-cloud/examples/serverless/alice-shareable-todolist/app/model"
"github.com/yandex-cloud/examples/serverless/alice-shareable-todolist/app/todolist"
)
type deleteItemAction struct {
itemText string
itemID model.ListItemID
listName string
listID model.TODOListID
}
func (h *Handler) deleteItemReqItem(ctx context.Context, req *aliceapi.Request) (*aliceapi.Response, errors.Err) {
action := &deleteItemAction{
listName: req.State.Session.ListName,
listID: req.State.Session.ListID,
}
if req.Request.Type == aliceapi.RequestTypeButton {
if req.Request.Payload == nil || req.Request.Payload.ChooseItemID == "" {
return nil, nil
}
action.itemText = req.Request.Payload.ChooseItemText
action.itemID = req.Request.Payload.ChooseItemID
return h.doDeleteItem(ctx, action)
}
action.itemText = req.Request.OriginalUtterance
return h.doDeleteItem(ctx, action)
}
func (h *Handler) deleteItemReqList(ctx context.Context, req *aliceapi.Request) (*aliceapi.Response, errors.Err) {
action := &deleteItemAction{
itemText: req.State.Session.ItemText,
itemID: req.State.Session.ItemID,
}
if req.Request.Type == aliceapi.RequestTypeButton {
if req.Request.Payload == nil || req.Request.Payload.ChooseListID == "" {
return nil, nil
}
action.listID = req.Request.Payload.ChooseListID
action.listName = req.Request.Payload.ChooseListName
return h.doDeleteItem(ctx, action)
}
action.listName = req.Request.OriginalUtterance
return h.doDeleteItem(ctx, action)
}
func (h *Handler) deleteItemFromScratch(ctx context.Context, req *aliceapi.Request) (*aliceapi.Response, errors.Err) {
if req.Request.Type != aliceapi.RequestTypeSimple {
return nil, nil
}
intnt := req.Request.NLU.Intents.DeleteItem
if intnt == nil {
return nil, nil
}
var action deleteItemAction
listName, ok := intnt.Slots.ListName.AsString()
if ok {
action.listName = listName
}
itemText, ok := intnt.Slots.Item.AsString()
if ok {
action.itemText = itemText
}
return h.doDeleteItem(ctx, &action)
}
func (h *Handler) doDeleteItem(ctx context.Context, action *deleteItemAction) (*aliceapi.Response, errors.Err) {
if action.listName == "" {
// list not selected, going to ask user
listButtons, err := h.suggestListButtons(ctx, filterWriteable)
if err != nil {
return nil, err
}
if len(listButtons) == 0 {
return respondNoLists("У вас пока нет списков, которые вы могли бы редактировать"), nil
}
text := "Из какого списка удалить запись?"
if action.itemText != "" {
text = fmt.Sprintf("Из какого списка удалить \"%s\"?", action.itemText)
}
return &aliceapi.Response{
Response: &aliceapi.Resp{Text: text, Buttons: listButtons},
State: &aliceapi.StateData{
ItemText: action.itemText,
State: aliceapi.StateDelItemReqList,
},
}, nil
}
if action.listID == "" {
// list name is select, but not resolved to id
entry, err := h.findListByName(ctx, action.listName)
if err != nil {
return nil, err
}
if entry == nil {
return &aliceapi.Response{
Response: &aliceapi.Resp{
Text: fmt.Sprintf("Я не нашла у вас список \"%\"", action.listName),
},
}, nil
}
action.listID = entry.ListID
}
if action.itemText == "" {
// item not selected, going to ask user
buttons, err := h.suggestListItems(ctx, action.listID)
if err != nil {
return nil, err
}
return &aliceapi.Response{
Response: &aliceapi.Resp{
Text: fmt.Sprintf("Что удалить из \"%s\"?", action.listName),
Buttons: buttons,
},
State: &aliceapi.StateData{
State: aliceapi.StateDelItemReqItem,
ListID: action.listID,
ListName: action.listName,
},
}, nil
}
if action.itemID == "" {
// item is selected, but not resolved to id
item, err := h.findItemByName(ctx, action.listID, action.itemText)
if err != nil {
return nil, err
}
if item == nil {
return &aliceapi.Response{Response: &aliceapi.Resp{
Text: fmt.Sprintf("Я не нашла \"%s\" в \"%s\"", action.itemText, action.listName),
}}, nil
}
action.itemID = item.ID
action.itemText = item.Text
}
err := h.todoListService.RemoveItem(ctx, &todolist.ItemRemoveRequest{
ListID: action.listID,
ItemID: action.itemID,
})
if err == nil {
return &aliceapi.Response{Response: &aliceapi.Resp{
Text: fmt.Sprintf("Готово, удалила \"%s\" из \"%s\"", action.itemText, action.listName),
}}, nil
}
switch err.GetCode() {
case errors.CodeUnauthorized:
return &aliceapi.Response{
Response: &aliceapi.Resp{Text: fmt.Sprintf(
"Похоже, у вас нет прав на редактирование списка \"%s\"", action.listName,
)},
}, nil
}
return nil, err
}
|
package main
import (
"fmt"
"net/http"
"log"
"encoding/json"
"structure"
"os"
"io/ioutil"
)
var port = "43000"
func main() {
fmt.Println("Server starting")
http.HandleFunc("/", indexPage)
//http.Handle("/", http.FileServer(http.Dir("./public")))
fs := http.StripPrefix("/static/", http.FileServer(http.Dir("static")))
http.Handle("/static/", fs)
fs = http.StripPrefix("/templates/", http.FileServer(http.Dir("templates")))
http.Handle("/templates/", fs)
http.HandleFunc("/update", update)
http.HandleFunc("/index.html", indexPage)
err := http.ListenAndServe(":" + port, nil)
checkError(err)
}
func indexPage(rw http.ResponseWriter, req *http.Request){
index, err := ioutil.ReadFile("src/templates/index.html")
if err != nil {
fmt.Printf("Error: %s\n", err)
rw.WriteHeader(http.StatusInternalServerError)
return
}
rw.Write([]byte(index))
}
func update(rw http.ResponseWriter, req *http.Request) {
var g structure.GameUpdates
err := json.NewDecoder(req.Body).Decode(&g)
if err != nil {
fmt.Printf("Error: %s\n", err)
rw.WriteHeader(http.StatusInternalServerError)
return
}
//log.Printf("Bomb: %s\n", g.Round.Bomb)
//log.Printf("CT Score: %v - T Score: %v\n", g.Map.TeamCT, g.Map.TeamT)
log.Printf("Phase: %v \nBomb: %v \nWinner: %v", g.Round.Phase, g.Round.Bomb, g.Round.RoundWinner)
}
func checkError(err error){
if err != nil {
fmt.Println("Fatal error: ", err.Error())
os.Exit(1)
}
}
|
package hlog
import (
"net/http"
"net/http/httputil"
"time"
"github.com/go-chi/chi/middleware"
"github.com/rs/zerolog"
"github.com/rs/zerolog/hlog"
)
type Middleware func(http.Handler) http.Handler
type ChainHandler struct {
Middlewares []Middleware
}
func Chain(m ...Middleware) ChainHandler {
return ChainHandler{Middlewares: m}
}
func (c ChainHandler) Use(m ...Middleware) ChainHandler {
c.Middlewares = append(c.Middlewares, m...)
return c
}
func (c ChainHandler) Handle(h http.Handler) http.Handler {
for i := range c.Middlewares {
h = c.Middlewares[len(c.Middlewares)-1-i](h)
}
return h
}
func DumpHandler(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if dump, err := httputil.DumpRequest(r, true); err == nil {
hlog.FromRequest(r).Debug().
Str("dump", string(dump)).
Msg("request dump")
}
next.ServeHTTP(w, r)
})
}
func Handler(logger zerolog.Logger, next http.Handler) http.Handler {
return Chain().
Use(middleware.Recoverer).
Use(hlog.NewHandler(logger)).
Use(hlog.AccessHandler(func(r *http.Request, status, size int, duration time.Duration) {
hlog.FromRequest(r).Debug().
Str("method", r.Method).
Str("url", r.URL.String()).
Int("status", status).
Int("size", size).
Dur("duration", duration).
Str("operation", "request").
Msg("processing request")
})).
Use(hlog.RemoteAddrHandler("ip")).
// If you are service is behind load balancer like nginx, you might want to
// use X-Request-ID instead of injecting request id. You can do some thing
// like this,
// r.Use(hlog.CustomHeaderHandler("reqId", "X-Request-Id"))
Use(hlog.RequestIDHandler("req_id", "Request-Id")).
// Use(DumpHandler).
Handle(next)
}
type HTTPClient interface {
Do(req *http.Request) (*http.Response, error)
}
type ClientLogger struct {
log zerolog.Logger
client HTTPClient
}
func Client(log zerolog.Logger, client HTTPClient) *ClientLogger {
return &ClientLogger{
log: log,
client: client,
}
}
func (c ClientLogger) Do(r *http.Request) (*http.Response, error) {
start := time.Now()
res, err := c.client.Do(r)
latency := time.Since(start)
var event *zerolog.Event
if err != nil {
event = c.log.Error().Err(err)
} else {
event = c.log.Debug()
}
event = event.Str("method", r.Method).Str("url", r.URL.String()).Dur("latency", latency)
if res != nil {
event.Int("status", res.StatusCode).
Int64("size", res.ContentLength)
} else {
event.Int("status", -1).
Int64("size", -1)
}
event.Msg("sending a request")
return res, err
}
|
package linkedlist
import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
)
func TestNode_String(t *testing.T) {
node := &Node{value: 10}
assert.Equal(t, fmt.Sprint(node), "10")
}
func TestList_Append(t *testing.T) {
list := &List{}
list.Append(1)
assert.Equal(t, list.head, list.tail)
assert.Len(t, list.ToArray(), 1)
assert.Equal(t, "1", fmt.Sprint(list))
list.Append(2)
assert.Len(t, list.ToArray(), 2)
assert.Equal(t, "1, 2", fmt.Sprint(list))
}
func TestList_Prepend(t *testing.T) {
list := &List{}
list.Prepend(1)
assert.Equal(t, list.head, list.tail)
assert.Len(t, list.ToArray(), 1)
assert.Equal(t, "1", fmt.Sprint(list))
list.Prepend(2)
assert.Len(t, list.ToArray(), 2)
assert.Equal(t, "2, 1", fmt.Sprint(list))
}
func TestList_Delete(t *testing.T) {
list := &List{}
list.Append(1)
list.Append(2)
list.Prepend(2)
assert.Len(t, list.ToArray(), 3)
assert.Equal(t, "2, 1, 2", fmt.Sprint(list))
list.Delete(2)
assert.Equal(t, "1, 2", fmt.Sprint(list))
list.Delete(2)
assert.Equal(t, "1", fmt.Sprint(list))
}
func TestList_DeleteAll(t *testing.T) {
list := &List{}
list.Append(1)
list.Append(2)
list.Prepend(2)
list.DeleteAll(2)
assert.Equal(t, "1", fmt.Sprint(list))
}
func TestList_DeleteHead(t *testing.T) {
list := &List{}
list.Append(1)
list.DeleteHead()
assert.Nil(t, list.head)
assert.Nil(t, list.tail)
list.Append(2)
list.Append(3)
list.DeleteHead()
assert.Equal(t, list.head, list.tail)
assert.Equal(t, "3", fmt.Sprint(list))
list.Append(4)
list.Append(5)
list.DeleteHead()
assert.Equal(t, "4, 5", fmt.Sprint(list))
}
func TestList_DeleteTail(t *testing.T) {
list := &List{}
list.Append(1)
list.DeleteTail()
assert.Nil(t, list.head)
assert.Nil(t, list.tail)
list.Append(2)
list.Append(3)
list.DeleteTail()
assert.Equal(t, list.head, list.tail)
assert.Equal(t, "2", fmt.Sprint(list))
list.Append(4)
list.Append(5)
list.DeleteTail()
assert.Equal(t, "2, 4", fmt.Sprint(list))
}
func TestList_FromIntArray(t *testing.T) {
list := &List{}
list.FromIntArray([]int{1, 2, 3})
assert.Equal(t, "1, 2, 3", fmt.Sprint(list))
}
func TestList_ToArray(t *testing.T) {
list := &List{}
list.FromIntArray([]int{1, 2, 3})
nodes := list.ToArray()
assert.Len(t, nodes, 3)
}
func TestList_String(t *testing.T) {
list := &List{}
list.FromIntArray([]int{1, 2, 3})
assert.Equal(t, "1, 2, 3", list.String())
}
func TestList_Reverse(t *testing.T) {
list := &List{}
list.Reverse()
assert.Equal(t, "", list.String())
list.Append(1)
list.Reverse()
assert.Equal(t, "1", list.String())
list.Append(2)
list.Reverse()
assert.Equal(t, "2, 1", list.String())
list.Append(3)
list.Reverse()
assert.Equal(t, "3, 1, 2", list.String())
}
func TestList_ReverseRecursive(t *testing.T) {
list := &List{}
list.ReverseRecursive()
assert.Equal(t, "", list.String())
list.Append(1)
list.ReverseRecursive()
assert.Equal(t, "1", list.String())
list.Append(2)
list.ReverseRecursive()
assert.Equal(t, "2, 1", list.String())
list.Append(3)
list.ReverseRecursive()
assert.Equal(t, "3, 1, 2", list.String())
}
func TestList_Find(t *testing.T) {
list := &List{}
list.FromIntArray([]int{1, 2, 3})
assert.Nil(t, list.Find(4))
assert.Equal(t, 1, list.Find(1).Value())
}
func TestList_Traverse(t *testing.T) {
list := &List{}
list.FromIntArray([]int{1, 2, 3})
values := make([]int, 0)
list.Traverse(func(value interface{}) {
values = append(values, value.(*Node).value.(int))
})
assert.Equal(t, []int{1, 2, 3}, values)
}
func TestList_TraverseReverse(t *testing.T) {
list := &List{}
list.FromIntArray([]int{1, 2, 3})
values := make([]int, 0)
list.TraverseReverse(func(value interface{}) {
values = append(values, value.(*Node).value.(int))
})
assert.Equal(t, []int{3, 2, 1}, values)
}
|
package common
import "github.com/HNB-ECO/HNB-Blockchain/HNB/common"
type NonceSet struct {
NI []*NonceItem
}
type NonceItem struct {
Key common.Address
Nonce uint64
}
type NonceStore interface {
GetNonce(address common.Address) (uint64, error)
SetNonce(address common.Address, nonce uint64) error
}
|
/*
Tencent is pleased to support the open source community by making Basic Service Configuration Platform available.
Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
Licensed under the MIT License (the "License"); you may not use this file except
in compliance with the License. You may obtain a copy of the License at
http://opensource.org/licenses/MIT
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 repo
import (
"encoding/base64"
"errors"
"fmt"
"sync"
"bscp.io/pkg/runtime/jsoni"
)
const (
// version the current bscp uses the version of the repo scheme, including
// project, warehouse, Node and other names to design and store content
version = "v1"
// nodeFrontPath is node full path's front path, reserved for future expansion.
nodeFrontPath = "/file/"
)
const (
// RepositoryType is repository type.
RepositoryType = "GENERIC"
// CategoryType is bscp repository category.
CategoryType = "LOCAL"
// RepositoryCfgType repository configuration type.
RepositoryCfgType = "local"
)
// header key.
const (
// HeaderKeyMETA file metadata in the format base64 (key1=value1&key2=value2). key is case sensitive.
HeaderKeyMETA = "X-BKREPO-META"
// HeaderKeyUID is repo uid header key.
HeaderKeyUID = "X-BKREPO-UID"
// HeaderKeySHA256 is repo file sha256 header key.
HeaderKeySHA256 = "X-BKREPO-SHA256"
// HeaderKeyOverwrite is repo upload overwrite flag header key.
HeaderKeyOverwrite = "X-BKREPO-OVERWRITE"
)
// error code.
const (
// errCodeProjectAlreadyExist repo project already exist.
errCodeProjectAlreadyExist = 251005
// errCodeRepoAlreadyExist repo repository already exist.
errCodeRepoAlreadyExist = 251007
// ErrCodeNodeAlreadyExist repo node already exist.
ErrCodeNodeAlreadyExist = 251012
// ErrCodeNodeNotExist repo node not exist.
ErrCodeNodeNotExist = 251010
)
// Config repo config.
type Config struct {
// Addrs repo server addresses.
Addrs []string
// Token repo auth token.
Token string
// Project repo bscp project name.
Project string
// User repo bscp project admin user name.
User string
}
// repoDiscovery repo server discovery.
type repoDiscovery struct {
servers []string
index int
sync.Mutex
}
// GetServers get repo server host.
func (s *repoDiscovery) GetServers() ([]string, error) {
s.Lock()
defer s.Unlock()
num := len(s.servers)
if num == 0 {
return []string{}, errors.New("repo is no server can be used")
}
if s.index < num-1 {
s.index = s.index + 1
return append(s.servers[s.index-1:], s.servers[:s.index-1]...), nil
}
s.index = 0
return append(s.servers[num-1:], s.servers[:num-1]...), nil
}
// CreateRepoReq is repo create repo request struct.
type CreateRepoReq struct {
// ProjectID is bscp project name in repo.
ProjectID string `json:"projectId"`
// Name is name of new repo.
Name string `json:"name"`
// Type is type of new repo(GENERIC).
Type string `json:"type"`
// Category is category type of new repo(LOCAL).
Category string `json:"category"`
// Public is repo public flag, default false not public to download.
Public bool `json:"public"`
// Configuration is configuration for new repo.
Configuration Configuration `json:"configuration"`
// Description is repo memo description.
Description string `json:"description"`
}
// UploadFileReq is repo upload file request struct
type UploadFileReq struct {
// BizID is business ID
BizID uint32 `json:"bizID"`
// AppID is application ID
AppID uint32 `json:"appID"`
// Content is base64 encoded content of file
Content string `json:"content"`
}
// UploadResp upload response
// Docs https://github.com/TencentBlueKing/bk-repo/blob/master/docs/apidoc/generic/simple.md
type UploadResp struct {
Code int `json:"code"`
Message string `json:"message"`
Data *UploadData `json:"data"`
}
// UploadResp upload data
type UploadData struct {
Size int64 `json:"size"` // bkrepo always return 0
Sha256 string `json:"sha256"`
}
// DownloadFileReq is repo download file request struct
type DownloadFileReq struct {
// BizID is business ID
BizID uint32 `json:"bizID"`
// AppID is application ID
AppID uint32 `json:"appID"`
// Sign is sha256 encoding of file
Sign string `json:"sign"`
}
// Configuration is repo configuration.
type Configuration struct {
// Type is configuration type(local).
Type string `json:"type"`
}
// GenerateTempDownloadURLReq is repo generate temp download url request struct.
type GenerateTempDownloadURLReq struct {
// ProjectID is bscp project name in repo.
ProjectID string `json:"projectId"`
// RepoName is name of new repo.
RepoName string `json:"repoName"`
// FullPathSet is node full path set.
FullPathSet []string `json:"fullPathSet"`
// ExpireSeconds is expire seconds.
ExpireSeconds uint32 `json:"expireSeconds"`
// Permits is count limit for download.
Permits uint32 `json:"permits"`
// Type is download type.
Type string `json:"type"`
}
// GenerateTempDownloadURLResp is repo generate temp download url response struct.
type GenerateTempDownloadURLResp struct {
// Code is response code.
Code int `json:"code"`
// Message is response message.
Message string `json:"message"`
// Data is response data.
Data []GenerateTempDownloadURLData `json:"data"`
// TraceID is trace id.
TraceID string `json:"traceId"`
}
// GenerateTempDownloadURLData is repo generate temp download url response data struct.
type GenerateTempDownloadURLData struct {
// ProjectID is bscp project name in repo.
ProjectID string `json:"projectId"`
// RepoName is name of new repo.
RepoName string `json:"repoName"`
// FullPath is node full path.
FullPath string `json:"fullPath"`
// URL is temp download url.
URL string `json:"url"`
// AuthorizedUserList is authorized user list.
AuthorizedUserList []string `json:"authorizedUserList"`
// AuthorizedIpList is authorized ip list.
AuthorizedIpList []string `json:"authorizedIpList"`
// ExpireDate is expire date.
ExpireDate string `json:"expireDate"`
// Permits is count limit for download.
Permits uint32 `json:"permits"`
// Type is download type.
Type string `json:"type"`
}
// FileMetadataValue ..
type FileMetadataValue struct {
ByteSize int64 `json:"byte_size"`
Sha256 string `json:"sha256"`
}
// GenRepoName generate repo repository name, like "bscp-{version}-{biz_id}".
func GenRepoName(bizID uint32) (string, error) {
if bizID == 0 {
return "", errors.New("biz_id should > 0")
}
return fmt.Sprintf("bscp-%s-biz-%d", version, bizID), nil
}
// GenNodeFullPath generate node full path, like "/file/c7d78b78205a2619eb2b80558f85ee188836ef5f4f317f8587ee38bc3712a8a"
func GenNodeFullPath(sign string) (string, error) {
if len(sign) == 0 {
return "", errors.New("sign is required")
}
return fmt.Sprintf("%s%s", nodeFrontPath, sign), nil
}
// NodeOption used to generate node path.
type NodeOption struct {
// Project bscp project in repo, optional. auth method is not required this parameter.
Project string
// BizID biz id.
BizID uint32
// Sign file sha256.
Sign string
}
// GenNodePath generate node upload/download path by download method.
// repo path format: /generic/{project}/{repoName}/{fullPath}
// normal path format: /generic/{project}/bscp-{version}-{biz_id}/file/{file sha256}
func GenNodePath(opt *NodeOption) (string, error) {
if opt == nil {
return "", errors.New("option is nil")
}
if len(opt.Project) == 0 {
return "", errors.New("project should > 0")
}
if opt.BizID == 0 {
return "", errors.New("biz_id should > 0")
}
if len(opt.Sign) != 64 {
return "", errors.New("file sha256 is not standard format")
}
repoName, err := GenRepoName(opt.BizID)
if err != nil {
return "", err
}
fullPath, err := GenNodeFullPath(opt.Sign)
if err != nil {
return "", err
}
return fmt.Sprintf("/generic/%s/%s%s", opt.Project, repoName, fullPath), nil
}
// NodeMeta node metadata info.
type NodeMeta struct {
BizID uint32 `json:"biz_id"`
AppID []uint32 `json:"app_id"`
TmplSpaceID []uint32 `json:"template_space_id"`
}
// String get content meta repo request format.
func (c NodeMeta) String() (string, error) {
var (
appIDs, tmplSpaceIDs []byte
err error
)
appIDs, err = jsoni.Marshal(c.AppID)
if err != nil {
return "", fmt.Errorf("marshal node metadata app ids failed, err: %v", err)
}
tmplSpaceIDs, err = jsoni.Marshal(c.TmplSpaceID)
if err != nil {
return "", fmt.Errorf("marshal node metadata tmplate space ids failed, err: %v", err)
}
return base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("biz_id=%d&app_id=%s&template_space_id=%s",
c.BizID, appIDs, tmplSpaceIDs))), nil
}
// GenS3NodeFullPath ..
func GenS3NodeFullPath(bizID uint32, sign string) (string, error) {
if len(sign) == 0 {
return "", errors.New("sign is required")
}
if len(sign) != 64 {
return "", errors.New("file sha256 is not standard format")
}
repoName := fmt.Sprintf("bscp-%s-biz-%d", version, bizID)
return fmt.Sprintf("/%s%s%s", repoName, nodeFrontPath, sign), nil
}
|
package main
import (
"fmt"
"image"
"image/png"
"math"
"math/rand"
"os"
"runtime"
"sync"
"time"
)
const (
WIDTH = 2560
HEIGHT = 2560
)
var SCENE scene
type ray struct {
origin, direction Vector
}
type sphere struct {
origin Vector
radius float64
color color
}
type scene struct {
spheres []sphere
}
type color struct {
r, g, b uint8
}
func main() {
// Sphere intersection test:
/*
SCENE = scene{makeSphereArray(
sphere{Vector{100, 70, 0}, 200, color{255, 0, 0},},
sphere{Vector{70, -70, 0}, 200, color{0, 0, 255},},
sphere{Vector{70, 70, -70}, 200, color{0, 255, 0},},
)}
*/
SCENE.randomSphereTest(5000)
saveImage(renderImage())
}
// Saves the image as a ".png" file to the out folder. Adds a time stamp to the file name.
func saveImage(_image image.Image) {
name := "out/render_" + time.Now().Format("2006_01_02_15_04_05") + ".png"
outputFile, err := os.Create(name)
err = png.Encode(outputFile, _image)
err = outputFile.Close()
if err != nil {
fmt.Println("Error Occurred")
fmt.Println(err)
}
}
// Renders the image from the scene.
func renderImage() image.Image {
// To measure the time it took to render the image.
start := time.Now()
var _image = image.NewRGBA(image.Rect(0, 0, WIDTH, HEIGHT))
// For a correct field of view:
d := (float64(WIDTH / 2)) / (math.Tan(math.Pi / 4))
// Raycast from origin (at [d, 0, 0]) through the particular pixel on the view port.
rays := make([]ray, WIDTH*HEIGHT)
c := 0
for y := 0; y < HEIGHT; y++ {
for x := 0; x < WIDTH; x++ {
c = y*HEIGHT + x
rays[c] = ray{
origin: Vector{d, 0, 0},
direction: Vector{-d, float64(x - WIDTH/2), float64(y - HEIGHT/2)},
}
}
}
// Hopefully concurrent raycasts.
prepRays := rayPipeline(rays)
getC := raycastWorker(prepRays)
// To stare at while it's running.
// go func() {
// for {
// fmt.Print("Working ")
// for i := 0; i < 20; i++ {
// fmt.Print(".")
// time.Sleep(time.Millisecond * 2000)
// }
// fmt.Println()
// }
// }()
// Debug output: Displays the amount of active goroutines and log. CPU cores.
go func() {
for {
fmt.Println()
fmt.Println(time.Now().Format(time.StampMilli))
fmt.Println(runtime.NumGoroutine(), "Gophers are working.")
fmt.Println(runtime.NumCPU(), "logical CPU Cores are available.")
time.Sleep(time.Millisecond * 1000)
}
}()
// Converts the output color channel to an array.
pixels := make([]color, WIDTH*HEIGHT)
i := 0
for n := range getC {
pixels[i] = n
i++
}
// Converts the array to an image file.
for y := 0; y < HEIGHT; y++ {
for x := 0; x < WIDTH; x++ {
// TODO: Not working properly for non square, rectangular images.
pO := _image.PixOffset(x, y)
pI := x*WIDTH + y
_image.Pix[pO] = pixels[pI].r
_image.Pix[pO+1] = pixels[pI].g
_image.Pix[pO+2] = pixels[pI].b
_image.Pix[pO+3] = 255
}
}
fmt.Println("RENDER TIME:", time.Since(start))
return _image
}
// Populates a chanel with the rays...
func rayPipeline(rays []ray) <-chan ray {
var out = make(chan ray)
go func() {
for n := range rays {
out <- rays[n]
}
close(out)
}()
return out
}
// ... passes it on to the Worker func.
func raycastWorker(in <-chan ray) <-chan color {
var wg sync.WaitGroup
wg.Add(12)
var out = make(chan color)
go func() {
for i := 0; i < 12; i++ {
go func() {
defer wg.Done()
for n := range in {
out <- n.intersectsWith().color
}
}()
}
wg.Wait()
close(out)
}()
return out
}
// Solves the equation for Line–Sphere intersection. Returns the closest Sphere it intersects with.
func (r ray) intersectsWith() sphere {
abs, closestSphere := math.MaxFloat64, sphere{}
for n := range SCENE.spheres {
s := SCENE.spheres[n]
v := Vector{
X1: r.origin.X1 - s.origin.X1,
X2: r.origin.X2 - s.origin.X2,
X3: r.origin.X3 - s.origin.X3,
}
disc := math.Pow(2*r.direction.GetDotProduct(v), 2) -
(4*r.direction.GetVecSquared())*(v.GetVecSquared()-
math.Pow(s.radius, 2))
// There is no solution:
if disc < 0 {
n++
}
div := 2 * r.direction.GetVecSquared()
b := -2 * r.direction.GetDotProduct(v)
lambda0 := (b + math.Sqrt(disc)) / div
lambda1 := (b - math.Sqrt(disc)) / div
p0 := r.getPointForLambda(lambda0)
p1 := r.getPointForLambda(lambda1)
abs0 := p0.DifferenceVector(r.origin).GetAbs()
abs1 := p1.DifferenceVector(r.origin).GetAbs()
if abs0 < abs1 {
if abs0 < abs {
abs = abs0
closestSphere = s
}
} else {
if abs1 < abs {
abs = abs1
closestSphere = s
}
}
}
return closestSphere
}
// Returns the Parameters of the function as an array of spheres.
func makeSphereArray(spheres ...sphere) []sphere {
return spheres
}
// Returns a Point on the line for a given value.
func (r ray) getPointForLambda(l float64) Vector {
v := Vector{
X1: r.origin.X1 + (l * r.direction.X1),
X2: r.origin.X2 + (l * r.direction.X2),
X3: r.origin.X3 + (l * r.direction.X3),
}
return v
}
// Populates the Scene with Spheres of random color at random positions.
func (s *scene) randomSphereTest(n int) {
seed := time.Now().Unix()
rand.Seed(seed)
fmt.Println("Seed: ", seed)
s.spheres = make([]sphere, n)
for i := 0; i < n; i++ {
s.spheres[i] = sphere{
origin: Vector{
rand.Float64()*WIDTH - (WIDTH / 2),
rand.Float64()*WIDTH - (WIDTH / 2),
rand.Float64()*WIDTH - (WIDTH / 2),
},
radius: 10,
color: color{
uint8(rand.Intn(255)),
uint8(rand.Intn(255)),
uint8(rand.Intn(255)),
},
}
}
}
|
package main
import "fmt"
//append() 为切片追加元素
func main() {
s1 := []int{1, 2, 3}
fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))
//s1[3] = 4 //错误写法， 会导致编译错误：索引越界
//调用append函数必须用原来的切片变量接收返回值
s1 = append(s1, 4)
fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))
s2 := []int{5, 6, 7, 8, 9, 10, 11, 12, 13}
s1 = append(s1, s2...) // ...表示拆开
fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))
}
|
// Copyright 2019 PingCAP, Inc.
//
// 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 chunk
import (
"bufio"
"io"
"os"
"strconv"
errors2 "github.com/pingcap/errors"
"github.com/pingcap/tidb/config"
"github.com/pingcap/tidb/parser/terror"
"github.com/pingcap/tidb/types"
"github.com/pingcap/tidb/util/checksum"
"github.com/pingcap/tidb/util/disk"
"github.com/pingcap/tidb/util/encrypt"
"github.com/pingcap/tidb/util/memory"
)
// ListInDisk represents a slice of chunks storing in temporary disk.
type ListInDisk struct {
fieldTypes []*types.FieldType
numRowsOfEachChunk []int
rowNumOfEachChunkFirstRow []int
totalNumRows int
diskTracker *disk.Tracker // track disk usage.
dataFile diskFileReaderWriter
offsetFile diskFileReaderWriter
}
// diskFileReaderWriter represents a Reader and a Writer for the temporary disk file.
type diskFileReaderWriter struct {
disk *os.File
w io.WriteCloser
// offWrite is the current offset for writing.
offWrite int64
checksumWriter *checksum.Writer
cipherWriter *encrypt.Writer // cipherWriter is only enable when config SpilledFileEncryptionMethod is "aes128-ctr"
// ctrCipher stores the key and nonce using by aes encrypt io layer
ctrCipher *encrypt.CtrCipher
}
func (l *diskFileReaderWriter) initWithFileName(fileName string) (err error) {
l.disk, err = os.CreateTemp(config.GetGlobalConfig().TempStoragePath, fileName)
if err != nil {
return errors2.Trace(err)
}
var underlying io.WriteCloser = l.disk
if config.GetGlobalConfig().Security.SpilledFileEncryptionMethod != config.SpilledFileEncryptionMethodPlaintext {
// The possible values of SpilledFileEncryptionMethod are "plaintext", "aes128-ctr"
l.ctrCipher, err = encrypt.NewCtrCipher()
if err != nil {
return
}
l.cipherWriter = encrypt.NewWriter(l.disk, l.ctrCipher)
underlying = l.cipherWriter
}
l.checksumWriter = checksum.NewWriter(underlying)
l.w = l.checksumWriter
return
}
func (l *diskFileReaderWriter) getReader() io.ReaderAt {
var underlying io.ReaderAt = l.disk
if l.ctrCipher != nil {
underlying = NewReaderWithCache(encrypt.NewReader(l.disk, l.ctrCipher), l.cipherWriter.GetCache(), l.cipherWriter.GetCacheDataOffset())
}
if l.checksumWriter != nil {
underlying = NewReaderWithCache(checksum.NewReader(underlying), l.checksumWriter.GetCache(), l.checksumWriter.GetCacheDataOffset())
}
return underlying
}
func (l *diskFileReaderWriter) getSectionReader(off int64) *io.SectionReader {
checksumReader := l.getReader()
r := io.NewSectionReader(checksumReader, off, l.offWrite-off)
return r
}
func (l *diskFileReaderWriter) getWriter() io.Writer {
return l.w
}
var defaultChunkListInDiskPath = "chunk.ListInDisk"
var defaultChunkListInDiskOffsetPath = "chunk.ListInDiskOffset"
// NewListInDisk creates a new ListInDisk with field types.
func NewListInDisk(fieldTypes []*types.FieldType) *ListInDisk {
l := &ListInDisk{
fieldTypes: fieldTypes,
// TODO(fengliyuan): set the quota of disk usage.
diskTracker: disk.NewTracker(memory.LabelForChunkListInDisk, -1),
}
return l
}
func (l *ListInDisk) initDiskFile() (err error) {
err = disk.CheckAndInitTempDir()
if err != nil {
return
}
err = l.dataFile.initWithFileName(defaultChunkListInDiskPath + strconv.Itoa(l.diskTracker.Label()))
if err != nil {
return
}
err = l.offsetFile.initWithFileName(defaultChunkListInDiskOffsetPath + strconv.Itoa(l.diskTracker.Label()))
return
}
// Len returns the number of rows in ListInDisk
func (l *ListInDisk) Len() int {
return l.totalNumRows
}
// GetDiskTracker returns the memory tracker of this List.
func (l *ListInDisk) GetDiskTracker() *disk.Tracker {
return l.diskTracker
}
// Add adds a chunk to the ListInDisk. Caller must make sure the input chk
// is not empty and not used any more and has the same field types.
// Warning: Do not use Add concurrently.
func (l *ListInDisk) Add(chk *Chunk) (err error) {
if chk.NumRows() == 0 {
return errors2.New("chunk appended to List should have at least 1 row")
}
if l.dataFile.disk == nil {
err = l.initDiskFile()
if err != nil {
return
}
}
// Append data
chkInDisk := chunkInDisk{Chunk: chk, offWrite: l.dataFile.offWrite}
n, err := chkInDisk.WriteTo(l.dataFile.getWriter())
l.dataFile.offWrite += n
if err != nil {
return
}
// Append offsets
offsetsOfRows := chkInDisk.getOffsetsOfRows()
l.numRowsOfEachChunk = append(l.numRowsOfEachChunk, len(offsetsOfRows))
l.rowNumOfEachChunkFirstRow = append(l.rowNumOfEachChunkFirstRow, l.totalNumRows)
n2, err := offsetsOfRows.WriteTo(l.offsetFile.getWriter())
l.offsetFile.offWrite += n2
if err != nil {
return
}
l.diskTracker.Consume(n + n2)
l.totalNumRows += chk.NumRows()
return
}
// GetChunk gets a Chunk from the ListInDisk by chkIdx.
func (l *ListInDisk) GetChunk(chkIdx int) (*Chunk, error) {
chk := NewChunkWithCapacity(l.fieldTypes, l.NumRowsOfChunk(chkIdx))
chkSize := l.numRowsOfEachChunk[chkIdx]
firstRowOffset, err := l.getOffset(uint32(chkIdx), 0)
if err != nil {
return nil, err
}
// this channel is big enough and will never be blocked.
formatCh := make(chan rowInDisk, chkSize)
var formatChErr error
go func() {
defer close(formatCh)
// If the row is small, a bufio can significantly improve the performance. As benchmark shows, it's still not bad
// for longer rows.
r := bufio.NewReader(l.dataFile.getSectionReader(firstRowOffset))
format := rowInDisk{numCol: len(l.fieldTypes)}
for rowIdx := 0; rowIdx < chkSize; rowIdx++ {
_, err = format.ReadFrom(r)
if err != nil {
formatChErr = err
break
}
formatCh <- format
}
}()
for format := range formatCh {
_, chk = format.toRow(l.fieldTypes, chk)
}
return chk, formatChErr
}
// GetRow gets a Row from the ListInDisk by RowPtr.
func (l *ListInDisk) GetRow(ptr RowPtr) (row Row, err error) {
row, _, err = l.GetRowAndAppendToChunk(ptr, nil)
return row, err
}
// GetRowAndAppendToChunk gets a Row from the ListInDisk by RowPtr. Return the Row and the Ref Chunk.
func (l *ListInDisk) GetRowAndAppendToChunk(ptr RowPtr, chk *Chunk) (row Row, _ *Chunk, err error) {
off, err := l.getOffset(ptr.ChkIdx, ptr.RowIdx)
if err != nil {
return
}
r := l.dataFile.getSectionReader(off)
format := rowInDisk{numCol: len(l.fieldTypes)}
_, err = format.ReadFrom(r)
if err != nil {
return row, nil, err
}
row, chk = format.toRow(l.fieldTypes, chk)
return row, chk, err
}
func (l *ListInDisk) getOffset(chkIdx uint32, rowIdx uint32) (int64, error) {
offsetInOffsetFile := l.rowNumOfEachChunkFirstRow[chkIdx] + int(rowIdx)
b := make([]byte, 8)
reader := l.offsetFile.getSectionReader(int64(offsetInOffsetFile) * 8)
n, err := io.ReadFull(reader, b)
if err != nil {
return 0, err
}
if n != 8 {
return 0, errors2.New("The file spilled is broken, can not get data offset from the disk")
}
return bytesToI64Slice(b)[0], nil
}
// NumRowsOfChunk returns the number of rows of a chunk in the ListInDisk.
func (l *ListInDisk) NumRowsOfChunk(chkID int) int {
return l.numRowsOfEachChunk[chkID]
}
// NumChunks returns the number of chunks in the ListInDisk.
func (l *ListInDisk) NumChunks() int {
return len(l.numRowsOfEachChunk)
}
// Close releases the disk resource.
func (l *ListInDisk) Close() error {
if l.dataFile.disk != nil {
l.diskTracker.Consume(-l.diskTracker.BytesConsumed())
terror.Call(l.dataFile.disk.Close)
terror.Log(os.Remove(l.dataFile.disk.Name()))
}
if l.offsetFile.disk != nil {
terror.Call(l.offsetFile.disk.Close)
terror.Log(os.Remove(l.offsetFile.disk.Name()))
}
return nil
}
// chunkInDisk represents a chunk in disk format. Each row of the chunk
// is serialized and in sequence ordered. The format of each row is like
// the struct diskFormatRow, put size of each column first, then the
// data of each column.
//
// For example, a chunk has 2 rows and 3 columns, the disk format of the
// chunk is as follow:
//
// [size of row0 column0], [size of row0 column1], [size of row0 column2]
// [data of row0 column0], [data of row0 column1], [data of row0 column2]
// [size of row1 column0], [size of row1 column1], [size of row1 column2]
// [data of row1 column0], [data of row1 column1], [data of row1 column2]
//
// If a column of a row is null, the size of it is -1 and the data is empty.
type chunkInDisk struct {
*Chunk
// offWrite is the current offset for writing.
offWrite int64
// offsetsOfRows stores the offset of each row.
offsetsOfRows offsetsOfRows
}
type offsetsOfRows []int64
// WriteTo serializes the offsetsOfRow, and writes to w.
func (off offsetsOfRows) WriteTo(w io.Writer) (written int64, err error) {
n, err := w.Write(i64SliceToBytes(off))
return int64(n), err
}
// WriteTo serializes the chunk into the format of chunkInDisk, and
// writes to w.
func (chk *chunkInDisk) WriteTo(w io.Writer) (written int64, err error) {
var n int64
numRows := chk.NumRows()
chk.offsetsOfRows = make([]int64, 0, numRows)
var format *diskFormatRow
for rowIdx := 0; rowIdx < numRows; rowIdx++ {
format = convertFromRow(chk.GetRow(rowIdx), format)
chk.offsetsOfRows = append(chk.offsetsOfRows, chk.offWrite+written)
n, err = rowInDisk{diskFormatRow: *format}.WriteTo(w)
written += n
if err != nil {
return
}
}
return
}
// getOffsetsOfRows gets the offset of each row.
func (chk *chunkInDisk) getOffsetsOfRows() offsetsOfRows { return chk.offsetsOfRows }
// rowInDisk represents a Row in format of diskFormatRow.
type rowInDisk struct {
numCol int
diskFormatRow
}
// WriteTo serializes a row of the chunk into the format of
// diskFormatRow, and writes to w.
func (row rowInDisk) WriteTo(w io.Writer) (written int64, err error) {
n, err := w.Write(i64SliceToBytes(row.sizesOfColumns))
written += int64(n)
if err != nil {
return
}
for _, data := range row.cells {
n, err = w.Write(data)
written += int64(n)
if err != nil {
return
}
}
return
}
// ReadFrom reads data of r, deserializes it from the format of diskFormatRow
// into Row.
func (row *rowInDisk) ReadFrom(r io.Reader) (n int64, err error) {
b := make([]byte, 8*row.numCol)
var n1 int
n1, err = io.ReadFull(r, b)
n += int64(n1)
if err != nil {
return
}
row.sizesOfColumns = bytesToI64Slice(b)
row.cells = make([][]byte, 0, row.numCol)
for _, size := range row.sizesOfColumns {
if size == -1 {
continue
}
cell := make([]byte, size)
row.cells = append(row.cells, cell)
n1, err = io.ReadFull(r, cell)
n += int64(n1)
if err != nil {
return
}
}
return
}
// diskFormatRow represents a row in a chunk in disk format. The disk format
// of a row is described in the doc of chunkInDisk.
type diskFormatRow struct {
// sizesOfColumns stores the size of each column in a row.
// -1 means the value of this column is null.
sizesOfColumns []int64 // -1 means null
// cells represents raw data of not-null columns in one row.
// In convertFromRow, data from Row is shallow copied to cells.
// In toRow, data in cells is deep copied to Row.
cells [][]byte
}
// convertFromRow serializes one row of chunk to diskFormatRow, then
// we can use diskFormatRow to write to disk.
func convertFromRow(row Row, reuse *diskFormatRow) (format *diskFormatRow) {
numCols := row.Chunk().NumCols()
if reuse != nil {
format = reuse
format.sizesOfColumns = format.sizesOfColumns[:0]
format.cells = format.cells[:0]
} else {
format = &diskFormatRow{
sizesOfColumns: make([]int64, 0, numCols),
cells: make([][]byte, 0, numCols),
}
}
for colIdx := 0; colIdx < numCols; colIdx++ {
if row.IsNull(colIdx) {
format.sizesOfColumns = append(format.sizesOfColumns, -1)
} else {
cell := row.GetRaw(colIdx)
format.sizesOfColumns = append(format.sizesOfColumns, int64(len(cell)))
format.cells = append(format.cells, cell)
}
}
return
}
// toRow deserializes diskFormatRow to Row.
func (format *diskFormatRow) toRow(fields []*types.FieldType, chk *Chunk) (Row, *Chunk) {
if chk == nil || chk.IsFull() {
chk = NewChunkWithCapacity(fields, 1024)
}
var cellOff int
for colIdx, size := range format.sizesOfColumns {
col := chk.columns[colIdx]
if size == -1 { // isNull
col.AppendNull()
} else {
if col.isFixed() {
col.elemBuf = format.cells[cellOff]
col.finishAppendFixed()
} else {
col.AppendBytes(format.cells[cellOff])
}
cellOff++
}
}
return Row{c: chk, idx: chk.NumRows() - 1}, chk
}
// ReaderWithCache helps to read data that has not be flushed to underlying layer.
// By using ReaderWithCache, user can still write data into ListInDisk even after reading.
type ReaderWithCache struct {
r io.ReaderAt
cacheOff int64
cache []byte
}
// NewReaderWithCache returns a ReaderWithCache.
func NewReaderWithCache(r io.ReaderAt, cache []byte, cacheOff int64) *ReaderWithCache {
return &ReaderWithCache{
r: r,
cacheOff: cacheOff,
cache: cache,
}
}
// ReadAt implements the ReadAt interface.
func (r *ReaderWithCache) ReadAt(p []byte, off int64) (readCnt int, err error) {
readCnt, err = r.r.ReadAt(p, off)
if err != io.EOF {
return readCnt, err
}
if len(p) == readCnt {
return readCnt, err
} else if len(p) < readCnt {
return readCnt, errors2.Trace(errors2.Errorf("cannot read more data than user requested"+
"(readCnt: %v, len(p): %v", readCnt, len(p)))
}
// When got here, user input is not filled fully, so we need read data from cache.
err = nil
p = p[readCnt:]
beg := off - r.cacheOff
if beg < 0 {
// This happens when only partial data of user requested resides in r.cache.
beg = 0
}
end := int(beg) + len(p)
if end > len(r.cache) {
err = io.EOF
end = len(r.cache)
}
readCnt += copy(p, r.cache[beg:end])
return readCnt, err
}
|
package main
import (
"fmt"
)
func main() {
x := []int{3, 6, 9, 12, 15, 18}
fmt.Println(x[5])
fmt.Println(x)
fmt.Println(x[:])
fmt.Println(x[1:])
fmt.Println(x[:5])
fmt.Println(x[3:4])
fmt.Println("Here is for loop")
for i, v := range x {
fmt.Println(i, v)
//Alternative method
}
fmt.Println("The below one is Alternative method")
for i := 0; i <= 5; i++ {
fmt.Println(i, x[i])
}
}
|
package user_action
import (
"encoding/json"
"ibgame/logs"
"ibgame/models/user_model"
"io/ioutil"
"net/http"
"strings"
)
// Register 注册action
func Register(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
data, err := ioutil.ReadAll(r.Body)
if err != nil {
logs.Error.Println("ioutil.ReadAll err", err)
return
}
logs.Info.Println("ServeHTTP", "reqeust = ", string(data))
var param user_model.RegisterParam
err = json.Unmarshal(data, ¶m)
if param.Name == "" {
re := "注册名字为空"
ret := map[string]interface{}{"code": 401, "msg": "error", "data": re}
bytes, err := json.MarshalIndent(ret, " ", " ")
if err != nil {
logs.Error.Println("json:err", err)
}
w.Write(bytes)
return
}
if re, e := user_model.Register(param); e != nil {
logs.Error.Println("models.Register:err", err)
} else {
logs.Info.Println(re)
ret := map[string]interface{}{"code": 0, "msg": "ok", "data": re}
bytes, err := json.MarshalIndent(ret, " ", " ")
if err != nil {
logs.Error.Println("json:err", err)
}
w.Write(bytes)
}
}
// ParseAuthToken token解析
func ParseAuthToken(w http.ResponseWriter, r *http.Request) {
t := r.FormValue("token")
str := strings.Replace(t, " ", "+", -1)
logs.Info.Println("t", str)
user_model.ParseAuthToken(str)
}
|
package aes
import (
"crypto/aes"
"crypto/cipher"
"crypto/hmac"
"errors"
"hash"
"io"
)
func CTRStream(src io.Reader, dst io.Writer, key, iv []byte) error {
block, err := aes.NewCipher(key)
if err != nil {
return err
}
stream := cipher.NewCTR(block, iv)
if _, err = io.CopyBuffer(dst, cipher.StreamReader{S: stream, R: src},
make([]byte, defaultBufferSize)); err != nil {
return err
}
return nil
}
func CtrStreamEtM(src io.Reader, dst io.Writer, key, iv []byte, decrypt bool) error {
var stream, hc, err = initStream(key, iv)
if err != nil {
return err
}
if decrypt {
var readBuffer = make([]byte, defaultBufferSize+HMACHash.Size())
for {
var nr, err = src.Read(readBuffer)
if err != nil && err != io.EOF {
return err
}
if nr > 0 {
var size = nr - HMACHash.Size()
hc.Write(readBuffer[:size])
var mac = hc.Sum(nil)
if !hmac.Equal(readBuffer[size:nr], mac) {
return errors.New("HMAC verification failed")
}
hc.Write(mac)
var writeBuffer = make([]byte, size)
stream.XORKeyStream(writeBuffer, readBuffer[:size])
dst.Write(writeBuffer)
}
if err == io.EOF {
break
}
}
return nil
} else {
var writer = io.MultiWriter(dst, hc)
var readBuffer = make([]byte, defaultBufferSize)
for {
var nr, err = src.Read(readBuffer)
if err != nil && err != io.EOF {
return err
}
if nr > 0 {
writeBuffer := make([]byte, nr)
stream.XORKeyStream(writeBuffer, readBuffer[:nr])
writer.Write(writeBuffer)
writer.Write(hc.Sum(nil))
}
if err == io.EOF {
break
}
}
return nil
}
}
func initStream(key, iv []byte) (cipher.Stream, hash.Hash, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, nil, err
}
return cipher.NewCTR(block, iv), hmac.New(HMACHash.New, key), nil
}
|
package fixtures
import "time"
var newYork, _ = time.LoadLocation("America/New_York")
|
package src
import (
"github.com/ghodss/yaml"
appsv1 "k8s.io/api/apps/v1"
"encoding/json"
"io/ioutil"
"sync"
"path"
"log"
"strings"
"time"
"fmt"
"os"
"os/user"
"codeci/pkg/k8s"
"runtime"
"bytes"
"errors"
"os/exec"
"path/filepath"
)
//get resource yaml
func GetResourceYaml(filePath string) []byte {
bytes, err := ioutil.ReadFile(filePath)
if err != nil {
panic(err.Error())
}
return bytes
}
//getResourceType
func GetResourceType(bytes []byte) string{
typeJson, err := yaml.YAMLToJSON(bytes)
if err != nil {
panic("get resource type error !")
}
var typeIn interface{}
json.Unmarshal(typeJson, &typeIn)
return typeIn.(map[string]interface{})["kind"].(string)
}
//init pod data
func InitPodData(apiClient k8s.K8sClientInf, dataType string, namespace, path, padName, containerName, dbUser, dbPasswd, dbName string) {
queryBytes, _ := ioutil.ReadFile(path)
query := string(queryBytes)
query = strings.Replace(query, "`", "\\`", -1)
querySlice := strings.Split(query, ";")
sql := ""
for k, queryStr := range querySlice {
if len(queryStr) <2 {continue}
sql = sql +";"+ queryStr
if k%50 == 0 && k >0 {
sql = sql + ";"
command := "mysql -u"+dbUser+" -p"+dbPasswd+" "+dbName+" -e \""+string(sql)+"\""
_, _, err := apiClient.PodExecCommand(namespace, padName, command, containerName)
if err != nil {
log.Println("data exists or sql error!")
}
sql = ""
}
}
sql = sql + ";"
command := "mysql -u"+dbUser+" -p"+dbPasswd+" "+dbName+" -e \""+string(sql)+"\""
_, _, err := apiClient.PodExecCommand(namespace, padName, command, containerName)
if err != nil {
log.Println("data exists or sql error!")
}
}
//get data init file map
func GetDataInitFile() map[string]string {
dataInitFileMap := make(map[string]string, 0)
dataBytes := []byte{}
dataFilePath := filepath.Join(os.Getenv("HOME"), ".codeci", "data-init-status.json")
status := FileExist(dataFilePath)
if status {
dataBytes = ReadDataFile(dataFilePath)
}
json.Unmarshal(dataBytes, &dataInitFileMap)
return dataInitFileMap
}
//check pod status
func CheckPodStatus(apiClient k8s.K8sClientInf, deploy appsv1.Deployment) bool{
checkStatus := false
for {
deploys := apiClient.GetDeployments(deploy.Name)
if len(deploys) >0 {
if deploys[0].Status.Replicas >0 {
for _, condition := range deploys[0].Status.Conditions {
if condition.Type == "Available" && condition.Status == "True" {
checkStatus = true
break
}
}
}
}
if checkStatus {
return true
}
fmt.Print(".")
time.Sleep(2*time.Second)
}
return false
}
//check layer nodes (pods) status
func CheckLayNodesStatus(apiClient k8s.K8sClientInf, deploys []appsv1.Deployment) {
wg := sync.WaitGroup{}
wg.Add(len(deploys))
for _, deploy := range deploys {
go func(apiClient k8s.K8sClientInf, deploy appsv1.Deployment) {
CheckPodStatus(apiClient, deploy)
wg.Done()
}(apiClient, deploy)
}
wg.Wait()
}
//pod reset
func PodReset(apiClient k8s.K8sClientInf, resNodeMap map[string]*ResNode, dataInitFileMap map[string]string) map[string]string{
//scan resource file
for _, resNode := range resNodeMap {
ScanResFile(apiClient, resNode.Res.Path)
//update data init file
for i:=len(resNode.DataInitPath)-1 ;i>=0;i-- {
dataInitFileMap[resNode.DataInitPath[i]] = "false"
}
}
return dataInitFileMap
}
//scan data file
func ScanResFile(apiClient k8s.K8sClientInf, pathName string) {
rd, err := ioutil.ReadDir(pathName)
if err != nil {
log.Fatalln("scan data file - read file error!", err)
}
//resource delete
for _, fi := range rd {
if !fi.IsDir() {
dataExt := path.Ext(fi.Name())
switch(dataExt) {
case ".yaml":
bytes := GetResourceYaml(pathName+"/"+fi.Name())
resourceType := GetResourceType(bytes)
apiClient.ResDelete(resourceType, bytes)
break
}
}else{
ScanResFile(apiClient, pathName+"/"+fi.Name())
}
}
}
//read data file
func ReadDataFile(path string) []byte {
data, err := ioutil.ReadFile(path)
if err != nil {
log.Fatalln("read "+path+" file failed!", err)
}
return data
}
//tools print
func PrintlnRes(layerNodes []map[string]*ResNode) {
index := 0
for k,v := range layerNodes {
fmt.Println("[ layer:", k+1, ",", "service num:", len(v), "]")
for _, subV := range v {
if index == 0 {
fmt.Print(subV.Name)
}else{
fmt.Print(", ", subV.Name)
}
index++
}
fmt.Println("\n")
index = 0
}
}
//file exist
func FileExist(path string) bool {
_, err := os.Lstat(path)
return !os.IsNotExist(err)
}
//resource print
func ResourcePrint(res map[string]*ResNode) {
for _, v := range res {
fmt.Println(v.Id, v.ParentId, v.Name, v.Parent)
}
}
//println
func PrintLog() {
//to-do list
fmt.Println("")
//add logs
}
//get Home
func GetHome() (string, error) {
user, err := user.Current()
if nil == err {
return user.HomeDir, nil
}
// cross compile support
if "windows" == runtime.GOOS {
return homeWindows()
}
// Unix-like system, so just assume Unix
return homeUnix()
}
func homeUnix() (string, error) {
// First prefer the HOME environmental variable
if home := os.Getenv("HOME"); home != "" {
return home, nil
}
// If that fails, try the shell
var stdout bytes.Buffer
cmd := exec.Command("sh", "-c", "eval echo ~$USER")
cmd.Stdout = &stdout
if err := cmd.Run(); err != nil {
return "", err
}
result := strings.TrimSpace(stdout.String())
if result == "" {
return "", errors.New("blank output when reading home directory")
}
return result, nil
}
func homeWindows() (string, error) {
drive := os.Getenv("HOMEDRIVE")
path := os.Getenv("HOMEPATH")
home := drive + path
if drive == "" || path == "" {
home = os.Getenv("USERPROFILE")
}
if home == "" {
return "", errors.New("HOMEDRIVE, HOMEPATH, and USERPROFILE are blank")
}
return home, nil
}
//file or folder check exists
func FFExists(path string) bool {
_, err := os.Stat(path)
if err != nil {
if os.IsExist(err) {
return true
}
return false
}
return true
}
//catch
func Catch() {
if r := recover(); r != nil {
fmt.Println("ERROR:", r)
var err error
switch x := r.(type) {
case string:
err = errors.New(x)
case error:
err = x
default:
err = errors.New("")
}
if err != nil {
}
}
}
|
package loader
import (
"io/ioutil"
"os"
"testing"
"github.com/devspace-cloud/devspace/pkg/devspace/config/generated"
fakegenerated "github.com/devspace-cloud/devspace/pkg/devspace/config/generated/testing"
"github.com/devspace-cloud/devspace/pkg/devspace/config/versions/latest"
"github.com/devspace-cloud/devspace/pkg/util/fsutil"
fakekubeconfig "github.com/devspace-cloud/devspace/pkg/util/kubeconfig/testing"
"github.com/devspace-cloud/devspace/pkg/util/log"
yaml "gopkg.in/yaml.v2"
"gotest.tools/assert"
"k8s.io/client-go/tools/clientcmd/api"
)
type existsTestCase struct {
name string
files map[string]interface{}
configPath string
expectedanswer bool
}
func TestExists(t *testing.T) {
testCases := []existsTestCase{
existsTestCase{
name: "Only custom file name exists",
configPath: "mypath.yaml",
files: map[string]interface{}{
"mypath.yaml": "",
},
expectedanswer: true,
},
existsTestCase{
name: "Default file name does not exist",
files: map[string]interface{}{
"mypath.yaml": "",
},
expectedanswer: false,
},
}
dir, err := ioutil.TempDir("", "test")
if err != nil {
t.Fatalf("Error creating temporary directory: %v", err)
}
wdBackup, err := os.Getwd()
if err != nil {
t.Fatalf("Error getting current working directory: %v", err)
}
err = os.Chdir(dir)
if err != nil {
t.Fatalf("Error changing working directory: %v", err)
}
defer func() {
//Delete temp folder
err = os.Chdir(wdBackup)
if err != nil {
t.Fatalf("Error changing dir back: %v", err)
}
err = os.RemoveAll(dir)
if err != nil {
t.Fatalf("Error removing dir: %v", err)
}
}()
for _, testCase := range testCases {
testExists(testCase, t)
}
}
func testExists(testCase existsTestCase, t *testing.T) {
defer func() {
for _, path := range []string{".devspace/generated.yaml"} {
os.Remove(path)
}
}()
for path, data := range testCase.files {
dataAsYaml, err := yaml.Marshal(data)
assert.NilError(t, err, "Error parsing data of file %s in testCase %s", path, testCase.name)
err = fsutil.WriteToFile([]byte(dataAsYaml), path)
assert.NilError(t, err, "Error writing file %s in testCase %s", path, testCase.name)
}
loader := &configLoader{
options: &ConfigOptions{
ConfigPath: testCase.configPath,
},
}
exists := loader.Exists()
assert.Equal(t, exists, testCase.expectedanswer, "Unexpected answer in testCase %s", testCase.name)
}
type cloneTestCase struct {
name string
cloner ConfigOptions
expectedClone *ConfigOptions
expectedErr string
}
func TestClone(t *testing.T) {
testCases := []cloneTestCase{
cloneTestCase{
name: "Clone ConfigOptions",
cloner: ConfigOptions{
Profile: "clonerProf",
KubeContext: "clonerContext",
},
expectedClone: &ConfigOptions{
Profile: "clonerProf",
KubeContext: "clonerContext",
},
},
}
for _, testCase := range testCases {
clone, err := (&testCase.cloner).Clone()
if testCase.expectedErr == "" {
assert.NilError(t, err, "Error in testCase %s", testCase.name)
} else {
assert.Error(t, err, testCase.expectedErr, "Wrong or no error in testCase %s", testCase.name)
}
configAsYaml, err := yaml.Marshal(clone)
assert.NilError(t, err, "Error parsing clone in testCase %s", testCase.name)
expectedAsYaml, err := yaml.Marshal(testCase.expectedClone)
assert.NilError(t, err, "Error parsing expection to yaml in testCase %s", testCase.name)
assert.Equal(t, string(configAsYaml), string(expectedAsYaml), "Unexpected clone in testCase %s", testCase.name)
}
}
type loadTestCase struct {
name string
options ConfigOptions
returnedGenerated generated.Config
files map[string]interface{}
withProfile bool
expectedConfig *latest.Config
expectedErr string
}
func TestLoad(t *testing.T) {
testCases := []loadTestCase{
loadTestCase{
name: "Get from custom config file with profile",
options: ConfigOptions{
ConfigPath: "custom.yaml",
},
files: map[string]interface{}{
"custom.yaml": latest.Config{
Version: latest.Version,
Profiles: []*latest.ProfileConfig{
&latest.ProfileConfig{
Name: "active",
},
},
},
},
returnedGenerated: generated.Config{
ActiveProfile: "active",
},
withProfile: true,
expectedConfig: &latest.Config{
Version: latest.Version,
Dev: &latest.DevConfig{},
},
},
loadTestCase{
name: "Get from default file without profile",
options: ConfigOptions{
Profile: "myProfile",
},
files: map[string]interface{}{
"devspace.yaml": latest.Config{
Version: latest.Version,
},
},
expectedConfig: &latest.Config{
Version: latest.Version,
Dev: &latest.DevConfig{},
},
},
}
dir, err := ioutil.TempDir("", "test")
if err != nil {
t.Fatalf("Error creating temporary directory: %v", err)
}
wdBackup, err := os.Getwd()
if err != nil {
t.Fatalf("Error getting current working directory: %v", err)
}
err = os.Chdir(dir)
if err != nil {
t.Fatalf("Error changing working directory: %v", err)
}
defer func() {
//Delete temp folder
err = os.Chdir(wdBackup)
if err != nil {
t.Fatalf("Error changing dir back: %v", err)
}
err = os.RemoveAll(dir)
if err != nil {
t.Fatalf("Error removing dir: %v", err)
}
}()
for _, testCase := range testCases {
testLoad(testCase, t)
}
}
func testLoad(testCase loadTestCase, t *testing.T) {
defer func() {
for _, path := range []string{".devspace/generated.yaml", "devspace.yaml", "custom.yaml"} {
os.Remove(path)
}
}()
for path, data := range testCase.files {
dataAsYaml, err := yaml.Marshal(data)
assert.NilError(t, err, "Error parsing data of file %s in testCase %s", path, testCase.name)
err = fsutil.WriteToFile([]byte(dataAsYaml), path)
assert.NilError(t, err, "Error writing file %s in testCase %s", path, testCase.name)
}
loader := &configLoader{
options: &testCase.options,
log: log.Discard,
generatedLoader: &fakegenerated.Loader{
Config: testCase.returnedGenerated,
},
kubeConfigLoader: &fakekubeconfig.Loader{
RawConfig: &api.Config{},
},
}
var config *latest.Config
var err error
if testCase.withProfile {
config, err = loader.Load()
} else {
config, err = loader.LoadWithoutProfile()
}
if testCase.expectedErr == "" {
assert.NilError(t, err, "Error in testCase %s", testCase.name)
} else {
assert.Error(t, err, testCase.expectedErr, "Wrong or no error in testCase %s", testCase.name)
}
configAsYaml, err := yaml.Marshal(config)
assert.NilError(t, err, "Error parsing config in testCase %s", testCase.name)
expectedAsYaml, err := yaml.Marshal(testCase.expectedConfig)
assert.NilError(t, err, "Error parsing expection to yaml in testCase %s", testCase.name)
assert.Equal(t, string(configAsYaml), string(expectedAsYaml), "Unexpected config in testCase %s", testCase.name)
}
type setDevSpaceRootTestCase struct {
name string
configPath string
startDir string
files map[string]interface{}
expectedExists bool
expectedWorkDir string
expectedErr string
}
func TestSetDevSpaceRoot(t *testing.T) {
dir, err := ioutil.TempDir("", "test")
if err != nil {
t.Fatalf("Error creating temporary directory: %v", err)
}
wdBackup, err := os.Getwd()
if err != nil {
t.Fatalf("Error getting current working directory: %v", err)
}
err = os.Chdir(dir)
if err != nil {
t.Fatalf("Error changing working directory: %v", err)
}
defer func() {
//Delete temp folder
err = os.Chdir(wdBackup)
if err != nil {
t.Fatalf("Error changing dir back: %v", err)
}
err = os.RemoveAll(dir)
if err != nil {
t.Fatalf("Error removing dir: %v", err)
}
}()
testCases := []setDevSpaceRootTestCase{
setDevSpaceRootTestCase{
name: "No custom.yaml",
configPath: "custom.yaml",
files: map[string]interface{}{
"devspace.yaml": "",
},
expectedExists: false,
expectedWorkDir: dir,
},
setDevSpaceRootTestCase{
name: "No devspace.yaml",
expectedExists: false,
expectedWorkDir: dir,
},
setDevSpaceRootTestCase{
name: "Config exists",
files: map[string]interface{}{
"devspace.yaml": "",
},
startDir: "subDir",
expectedExists: true,
expectedWorkDir: dir,
},
}
for _, testCase := range testCases {
testSetDevSpaceRoot(testCase, t)
}
}
func testSetDevSpaceRoot(testCase setDevSpaceRootTestCase, t *testing.T) {
wdBackup, err := os.Getwd()
assert.NilError(t, err, "Error getting current working directory")
defer func() {
os.Chdir(wdBackup)
for _, path := range []string{"devspace.yaml", "custom.yaml"} {
os.Remove(path)
}
}()
for path, data := range testCase.files {
dataAsYaml, err := yaml.Marshal(data)
assert.NilError(t, err, "Error parsing data of file %s in testCase %s", path, testCase.name)
err = fsutil.WriteToFile([]byte(dataAsYaml), path)
assert.NilError(t, err, "Error writing file %s in testCase %s", path, testCase.name)
}
if testCase.startDir != "" {
os.Mkdir(testCase.startDir, os.ModePerm)
os.Chdir(testCase.startDir)
}
loader := &configLoader{
options: &ConfigOptions{
ConfigPath: testCase.configPath,
},
log: log.Discard,
}
exists, err := loader.SetDevSpaceRoot()
if testCase.expectedErr == "" {
assert.NilError(t, err, "Error in testCase %s", testCase.name)
} else {
assert.Error(t, err, testCase.expectedErr, "Wrong or no error in testCase %s", testCase.name)
}
assert.Equal(t, exists, testCase.expectedExists, "Unexpected existence answer in testCase %s", testCase.name)
wd, err := os.Getwd()
assert.NilError(t, err, "Error getting wd in testCase %s", testCase.name)
assert.Equal(t, wd, testCase.expectedWorkDir, "Unexpected work dir in testCase %s", testCase.name)
}
|
package Base58
import (
"testing"
)
const (
vv = "16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM"
)
var ii = []byte("00010966776006953d5567439e5e39f86a0d273beed61967f6")
// BenchmarkDecodeBase58 show benchmark test
func BenchmarkDecodeBase58(b *testing.B) {
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
DecodeBase58(vv)
}
b.StopTimer()
}
func BenchmarkEncodeBase58(b *testing.B) {
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
EncodeBase58(ii)
}
b.StopTimer()
}
|
package main
import "fmt"
func testFail() {
shouldReturnError := func(v ...interface{}) {
fmt.Println(v)
}
shouldReturnError(1, "v", make(chan interface{}))
}
|
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"net/url"
"os"
"strconv"
"time"
"github.com/aymerick/raymond"
"github.com/nektro/go-util/util"
discord "github.com/nektro/go.discord"
etc "github.com/nektro/go.etc"
oauth2 "github.com/nektro/go.oauth2"
"github.com/rakyll/statik/fs"
"github.com/valyala/fastjson"
. "github.com/nektro/go-util/alias"
_ "github.com/nektro/skarn/statik"
)
var (
config *Config
categoryNames = []string{"lit", "mov", "mus", "exe", "xxx", "etc"}
categoryValues map[string]CategoryMapValue
)
func main() {
util.Log("Initializing Skarn Request System...")
//
etc.Init("skarn", &config)
etc.ConfigAssertKeysNonEmpty(&config, "ID", "Secret", "BotToken", "Server")
etc.MFS.Add(http.Dir("./www/"))
statikFS, err := fs.New()
util.DieOnError(err)
etc.MFS.Add(http.FileSystem(statikFS))
catf, _ := etc.MFS.Open("/categories.json")
catb, _ := ioutil.ReadAll(catf)
json.Unmarshal(catb, &categoryValues)
etc.Database.CreateTableStruct("users", User{})
etc.Database.CreateTableStruct("requests", Request{})
etc.RunOnClose(func() {
util.Log("Gracefully shutting down...")
etc.Database.Close()
util.Log("Saved database to disk")
os.Exit(0)
})
//
raymond.RegisterHelper("icon", func(cat string) string {
return categoryValues[cat].Icon
})
raymond.RegisterHelper("domain", func(link string) string {
u, e := url.Parse(link)
if e != nil {
return "WWW"
}
return u.Host
})
raymond.RegisterHelper("name", func(userID int) string {
usrs := scanRowsUsers(etc.Database.QueryDoSelect("users", "id", strconv.FormatInt(int64(userID), 10)))
if len(usrs) == 0 {
return ""
}
return usrs[0].RealName
})
raymond.RegisterHelper("quality", func(cat string, item string) string {
i, _ := strconv.ParseInt(item, 10, 32)
return categoryValues[cat].Quality[i]
})
raymond.RegisterHelper("length", func(array []string) int {
return len(array)
})
//
http.HandleFunc("/", http.FileServer(etc.MFS).ServeHTTP)
http.HandleFunc("/login", oauth2.HandleOAuthLogin(isLoggedIn, "./verify", oauth2.ProviderDiscord, config.ID))
http.HandleFunc("/callback", oauth2.HandleOAuthCallback(oauth2.ProviderDiscord, config.ID, config.Secret, saveOAuth2Info, "./verify"))
http.HandleFunc("/verify", func(w http.ResponseWriter, r *http.Request) {
s, u, err := pageInit(r, w, http.MethodGet, true, false, false)
if err != nil {
return
}
tm, ok := s.Values["verify_time"]
if ok {
a := time.Now().Unix() - tm.(int64)
b := int64(time.Second * 60 * 1)
if a < b {
if !u.IsMember {
writeResponse(r, w, "Access Denied", "Must be a member. Please try again later.", "", "")
return // only query once every 1 mins
}
w.Header().Add("location", "./requests")
w.WriteHeader(http.StatusMovedPermanently)
return
}
}
snowflake := s.Values["user"].(string)
res, rcd := doDiscordAPIRequest(F("/guilds/%s/members/%s", config.Server, snowflake))
if rcd >= 400 {
writeResponse(r, w, "Discord Error", fastjson.GetString(res, "message"), "", "")
return // discord error
}
var dat discord.GuildMember
json.Unmarshal(res, &dat)
etc.Database.QueryDoUpdate("users", "nickname", dat.Nickname, "snowflake", snowflake)
etc.Database.QueryDoUpdate("users", "avatar", dat.User.Avatar, "snowflake", snowflake)
allowed := false
if containsAny(dat.Roles, config.Members) {
etc.Database.QueryDoUpdate("users", "is_member", "1", "snowflake", snowflake)
allowed = true
}
if containsAny(dat.Roles, config.Admins) {
etc.Database.QueryDoUpdate("users", "is_admin", "1", "snowflake", snowflake)
allowed = true
}
if !allowed {
etc.Database.QueryDoUpdate("users", "is_member", "0", "snowflake", snowflake)
etc.Database.QueryDoUpdate("users", "is_admin", "0", "snowflake", snowflake)
writeResponse(r, w, "Acess Denied", "No valid Discord Roles found.", "", "")
return
}
s.Values["verify_time"] = time.Now().Unix()
s.Save(r, w)
w.Header().Add("location", "./requests")
w.WriteHeader(http.StatusMovedPermanently)
})
http.HandleFunc("/requests", func(w http.ResponseWriter, r *http.Request) {
_, u, err := pageInit(r, w, http.MethodGet, true, true, false)
if err != nil {
return
}
writePage(r, w, u, "/requests.hbs", "open", "Open Requests", map[string]interface{}{
"tagline": "All of the requests that are currently unfilled can be found from here.",
"requests": scanRowsRequests(etc.Database.QueryDoSelect("requests", "filler", "-1")),
})
})
http.HandleFunc("/new", func(w http.ResponseWriter, r *http.Request) {
_, u, err := pageInit(r, w, http.MethodGet, true, true, false)
if err != nil {
return
}
writePage(r, w, u, "/new.hbs", "new", "New Request", map[string]interface{}{
"categories": categoryValues,
})
})
http.HandleFunc("/mine", func(w http.ResponseWriter, r *http.Request) {
_, u, err := pageInit(r, w, http.MethodGet, true, true, false)
if err != nil {
return
}
id := strconv.FormatInt(int64(u.ID), 10)
writePage(r, w, u, "/requests.hbs", "mine", "My Requests", map[string]interface{}{
"tagline": "All requests filed by you are here.",
"requests": scanRowsRequests(etc.Database.QueryDoSelect("requests", "owner", id)),
})
})
http.HandleFunc("/leaderboard", func(w http.ResponseWriter, r *http.Request) {
_, u, err := pageInit(r, w, http.MethodGet, true, true, false)
if err != nil {
return
}
writePage(r, w, u, "/leaderboard.hbs", "users", "Leaderboard", map[string]interface{}{
"users": scanRowsUsersComplete(etc.Database.QueryDoSelect("users", "is_member", "1")),
})
})
http.HandleFunc("/admin/users", func(w http.ResponseWriter, r *http.Request) {
_, u, err := pageInit(r, w, http.MethodGet, true, true, true)
if err != nil {
return
}
writePage(r, w, u, "/all_users.hbs", "a/u", "All Users", map[string]interface{}{
"users": scanRowsUsers(etc.Database.QueryDoSelectAll("users")),
})
})
http.HandleFunc("/admin/requests", func(w http.ResponseWriter, r *http.Request) {
_, u, err := pageInit(r, w, http.MethodGet, true, true, true)
if err != nil {
return
}
writePage(r, w, u, "/all_requests.hbs", "a/r", "All Requests", map[string]interface{}{
"requests": scanRowsRequests(etc.Database.QueryDoSelectAll("requests")),
})
})
//
http.HandleFunc("/api/request/create", func(w http.ResponseWriter, r *http.Request) {
_, u, err := pageInit(r, w, http.MethodPost, true, true, false)
if err != nil {
return
}
if assertPostFormValuesExist(r, "category") != nil {
writeResponse(r, w, "Missing POST Value", "", "./../../new", "Go back to /new")
return
}
cat := r.PostForm["category"][0]
if !util.Contains(categoryNames, cat) {
writeResponse(r, w, "Invalid Category", "", "./../../new", "Go back to /new")
return
}
if assertPostFormValuesExist(r, "quality_"+cat, "title", "link", "description") != nil {
writeResponse(r, w, "Missing POST Values", "Request description items are required.", "./../../new", "Go back to /new")
return // post value not found
}
q := r.PostForm["quality_"+cat][0]
t := r.PostForm["title"][0]
l := r.PostForm["link"][0]
d := r.PostForm["description"][0]
lerr := assertURLValidity(l)
if lerr != nil {
fmt.Fprintln(w, "E", "link", lerr.Error())
return // link is not a url
}
i := etc.Database.QueryNextID("requests")
o := u.ID
// success
etc.Database.QueryPrepared(true, F("insert into requests values (%d, %d, ?, '%s', ?, ?, ?, ?, 1, -1, '', '')", i, o, T()), cat, t, q, l, d)
makeAnnouncement(F("**[NEW]** <@%s> created a request for **%s**.", u.Snowflake, t))
writeResponse(r, w, "Success!", F("Added your request for %s", t), "./../../requests", "Back to home")
})
http.HandleFunc("/api/request/update_score", func(w http.ResponseWriter, r *http.Request) {
_, _, err := pageInit(r, w, http.MethodPost, true, true, true)
if err != nil {
return
}
if assertPostFormValuesExist(r, "id", "score") != nil {
fmt.Fprintln(w, "missing post value")
return
}
rid := r.PostForm["id"][0]
scr := r.PostForm["score"][0]
//
if !isInt(rid) || !isInt(scr) {
fmt.Fprintln(w, "invalid value")
return
}
//
etc.Database.QueryDoUpdate("requests", "points", scr, "id", rid)
fmt.Fprintln(w, "good")
})
http.HandleFunc("/api/request/fill", func(w http.ResponseWriter, r *http.Request) {
_, u, err := pageInit(r, w, http.MethodPost, true, true, false)
if err != nil {
return
}
if assertPostFormValuesExist(r, "id", "message") != nil {
return
}
rid := r.PostForm["id"][0]
msg := r.PostForm["message"][0]
//
req, own, err := queryRequestById(rid)
if err != nil {
return
}
if req.Filled {
return
}
//
etc.Database.QueryDoUpdate("requests", "filler", strconv.Itoa(u.ID), "id", rid)
etc.Database.QueryDoUpdate("requests", "filled_on", T(), "id", rid)
etc.Database.QueryDoUpdate("requests", "response", msg, "id", rid)
makeAnnouncement(F("**[FILL]** <@%s>'s request for **%s** was just filled by <@%s>.", own.Snowflake, req.Title, u.Snowflake))
fmt.Fprintln(w, "good")
})
http.HandleFunc("/api/request/unfill", func(w http.ResponseWriter, r *http.Request) {
_, u, err := pageInit(r, w, http.MethodPost, true, true, false)
if err != nil {
return
}
if assertPostFormValuesExist(r, "id") != nil {
return
}
rid := r.PostForm["id"][0]
req, own, err := queryRequestById(rid)
if err != nil {
return
}
if u.ID != own.ID && !u.IsAdmin {
return
}
//
etc.Database.QueryDoUpdate("requests", "filler", "-1", "id", rid)
etc.Database.QueryDoUpdate("requests", "filled_on", "", "id", rid)
etc.Database.QueryDoUpdate("requests", "response", "", "id", rid)
makeAnnouncement(F("**[UNFILL]** <@%s>'s just un-filled their request for **%s**.", own.Snowflake, req.Title))
fmt.Fprintln(w, "good")
})
http.HandleFunc("/api/request/delete", func(w http.ResponseWriter, r *http.Request) {
_, u, err := pageInit(r, w, http.MethodPost, true, true, false)
if err != nil {
return
}
if assertPostFormValuesExist(r, "id") != nil {
fmt.Fprintln(w, "missing post value")
return
}
rid := r.PostForm["id"][0]
req, own, err := queryRequestById(rid)
if err != nil {
return
}
if u.ID != own.ID && !u.IsAdmin {
return
}
//
etc.Database.QueryDelete("requests", "id", rid)
makeAnnouncement(F("**[DELETE]** <@%s>'s request for **%s** was just deleted.", own.Snowflake, req.Title))
fmt.Fprintln(w, "good")
})
//
p := strconv.Itoa(config.Port)
util.Log("Initialization complete. Starting server on port " + p)
http.ListenAndServe(":"+p, nil)
}
|
package collectors
import (
"encoding/json"
"errors"
"fmt"
"log"
"strings"
"time"
cclog "github.com/ClusterCockpit/cc-metric-collector/pkg/ccLogger"
lp "github.com/ClusterCockpit/cc-metric-collector/pkg/ccMetric"
"github.com/NVIDIA/go-nvml/pkg/nvml"
)
type NvidiaCollectorConfig struct {
ExcludeMetrics []string `json:"exclude_metrics,omitempty"`
ExcludeDevices []string `json:"exclude_devices,omitempty"`
AddPciInfoTag bool `json:"add_pci_info_tag,omitempty"`
UsePciInfoAsTypeId bool `json:"use_pci_info_as_type_id,omitempty"`
AddUuidMeta bool `json:"add_uuid_meta,omitempty"`
AddBoardNumberMeta bool `json:"add_board_number_meta,omitempty"`
AddSerialMeta bool `json:"add_serial_meta,omitempty"`
ProcessMigDevices bool `json:"process_mig_devices,omitempty"`
UseUuidForMigDevices bool `json:"use_uuid_for_mig_device,omitempty"`
UseSliceForMigDevices bool `json:"use_slice_for_mig_device,omitempty"`
}
type NvidiaCollectorDevice struct {
device nvml.Device
excludeMetrics map[string]bool
tags map[string]string
meta map[string]string
}
type NvidiaCollector struct {
metricCollector
config NvidiaCollectorConfig
gpus []NvidiaCollectorDevice
num_gpus int
}
func (m *NvidiaCollector) CatchPanic() {
if rerr := recover(); rerr != nil {
log.Print(rerr)
m.init = false
}
}
func (m *NvidiaCollector) Init(config json.RawMessage) error {
var err error
m.name = "NvidiaCollector"
m.config.AddPciInfoTag = false
m.config.UsePciInfoAsTypeId = false
m.config.ProcessMigDevices = false
m.config.UseUuidForMigDevices = false
m.config.UseSliceForMigDevices = false
m.setup()
if len(config) > 0 {
err = json.Unmarshal(config, &m.config)
if err != nil {
return err
}
}
m.meta = map[string]string{
"source": m.name,
"group": "Nvidia",
}
defer m.CatchPanic()
// Initialize NVIDIA Management Library (NVML)
ret := nvml.Init()
if ret != nvml.SUCCESS {
err = errors.New(nvml.ErrorString(ret))
cclog.ComponentError(m.name, "Unable to initialize NVML", err.Error())
return err
}
// Number of NVIDIA GPUs
num_gpus, ret := nvml.DeviceGetCount()
if ret != nvml.SUCCESS {
err = errors.New(nvml.ErrorString(ret))
cclog.ComponentError(m.name, "Unable to get device count", err.Error())
return err
}
// For all GPUs
idx := 0
m.gpus = make([]NvidiaCollectorDevice, num_gpus)
for i := 0; i < num_gpus; i++ {
// Skip excluded devices by ID
str_i := fmt.Sprintf("%d", i)
if _, skip := stringArrayContains(m.config.ExcludeDevices, str_i); skip {
cclog.ComponentDebug(m.name, "Skipping excluded device", str_i)
continue
}
// Get device handle
device, ret := nvml.DeviceGetHandleByIndex(i)
if ret != nvml.SUCCESS {
err = errors.New(nvml.ErrorString(ret))
cclog.ComponentError(m.name, "Unable to get device at index", i, ":", err.Error())
continue
}
// Get device's PCI info
pciInfo, ret := nvml.DeviceGetPciInfo(device)
if ret != nvml.SUCCESS {
err = errors.New(nvml.ErrorString(ret))
cclog.ComponentError(m.name, "Unable to get PCI info for device at index", i, ":", err.Error())
continue
}
// Create PCI ID in the common format used by the NVML.
pci_id := fmt.Sprintf(
nvml.DEVICE_PCI_BUS_ID_FMT,
pciInfo.Domain,
pciInfo.Bus,
pciInfo.Device)
// Skip excluded devices specified by PCI ID
if _, skip := stringArrayContains(m.config.ExcludeDevices, pci_id); skip {
cclog.ComponentDebug(m.name, "Skipping excluded device", pci_id)
continue
}
// Select which value to use as 'type-id'.
// The PCI ID is commonly required in SLURM environments because the
// numberic IDs used by SLURM and the ones used by NVML might differ
// depending on the job type. The PCI ID is more reliable but is commonly
// not recorded for a job, so it must be added manually in prologue or epilogue
// e.g. to the comment field
tid := str_i
if m.config.UsePciInfoAsTypeId {
tid = pci_id
}
// Now we got all infos together, populate the device list
g := &m.gpus[idx]
// Add device handle
g.device = device
// Add tags
g.tags = map[string]string{
"type": "accelerator",
"type-id": tid,
}
// Add PCI info as tag if not already used as 'type-id'
if m.config.AddPciInfoTag && !m.config.UsePciInfoAsTypeId {
g.tags["pci_identifier"] = pci_id
}
g.meta = map[string]string{
"source": m.name,
"group": "Nvidia",
}
if m.config.AddBoardNumberMeta {
board, ret := nvml.DeviceGetBoardPartNumber(device)
if ret != nvml.SUCCESS {
cclog.ComponentError(m.name, "Unable to get boart part number for device at index", i, ":", err.Error())
} else {
g.meta["board_number"] = board
}
}
if m.config.AddSerialMeta {
serial, ret := nvml.DeviceGetSerial(device)
if ret != nvml.SUCCESS {
cclog.ComponentError(m.name, "Unable to get serial number for device at index", i, ":", err.Error())
} else {
g.meta["serial"] = serial
}
}
if m.config.AddUuidMeta {
uuid, ret := nvml.DeviceGetUUID(device)
if ret != nvml.SUCCESS {
cclog.ComponentError(m.name, "Unable to get UUID for device at index", i, ":", err.Error())
} else {
g.meta["uuid"] = uuid
}
}
// Add excluded metrics
g.excludeMetrics = map[string]bool{}
for _, e := range m.config.ExcludeMetrics {
g.excludeMetrics[e] = true
}
// Increment the index for the next device
idx++
}
m.num_gpus = idx
m.init = true
return nil
}
func readMemoryInfo(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
if !device.excludeMetrics["nv_fb_mem_total"] || !device.excludeMetrics["nv_fb_mem_used"] || !device.excludeMetrics["nv_fb_mem_reserved"] {
var total uint64
var used uint64
var reserved uint64 = 0
var v2 bool = false
meminfo, ret := nvml.DeviceGetMemoryInfo(device.device)
if ret != nvml.SUCCESS {
err := errors.New(nvml.ErrorString(ret))
return err
}
total = meminfo.Total
used = meminfo.Used
if !device.excludeMetrics["nv_fb_mem_total"] {
t := float64(total) / (1024 * 1024)
y, err := lp.New("nv_fb_mem_total", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now())
if err == nil {
y.AddMeta("unit", "MByte")
output <- y
}
}
if !device.excludeMetrics["nv_fb_mem_used"] {
f := float64(used) / (1024 * 1024)
y, err := lp.New("nv_fb_mem_used", device.tags, device.meta, map[string]interface{}{"value": f}, time.Now())
if err == nil {
y.AddMeta("unit", "MByte")
output <- y
}
}
if v2 && !device.excludeMetrics["nv_fb_mem_reserved"] {
r := float64(reserved) / (1024 * 1024)
y, err := lp.New("nv_fb_mem_reserved", device.tags, device.meta, map[string]interface{}{"value": r}, time.Now())
if err == nil {
y.AddMeta("unit", "MByte")
output <- y
}
}
}
return nil
}
func readBarMemoryInfo(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
if !device.excludeMetrics["nv_bar1_mem_total"] || !device.excludeMetrics["nv_bar1_mem_used"] {
meminfo, ret := nvml.DeviceGetBAR1MemoryInfo(device.device)
if ret != nvml.SUCCESS {
err := errors.New(nvml.ErrorString(ret))
return err
}
if !device.excludeMetrics["nv_bar1_mem_total"] {
t := float64(meminfo.Bar1Total) / (1024 * 1024)
y, err := lp.New("nv_bar1_mem_total", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now())
if err == nil {
y.AddMeta("unit", "MByte")
output <- y
}
}
if !device.excludeMetrics["nv_bar1_mem_used"] {
t := float64(meminfo.Bar1Used) / (1024 * 1024)
y, err := lp.New("nv_bar1_mem_used", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now())
if err == nil {
y.AddMeta("unit", "MByte")
output <- y
}
}
}
return nil
}
func readUtilization(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
isMig, ret := nvml.DeviceIsMigDeviceHandle(device.device)
if ret != nvml.SUCCESS {
err := errors.New(nvml.ErrorString(ret))
return err
}
if isMig {
return nil
}
if !device.excludeMetrics["nv_util"] || !device.excludeMetrics["nv_mem_util"] {
// Retrieves the current utilization rates for the device's major subsystems.
//
// Available utilization rates
// * Gpu: Percent of time over the past sample period during which one or more kernels was executing on the GPU.
// * Memory: Percent of time over the past sample period during which global (device) memory was being read or written
//
// Note:
// * During driver initialization when ECC is enabled one can see high GPU and Memory Utilization readings.
// This is caused by ECC Memory Scrubbing mechanism that is performed during driver initialization.
// * On MIG-enabled GPUs, querying device utilization rates is not currently supported.
util, ret := nvml.DeviceGetUtilizationRates(device.device)
if ret == nvml.SUCCESS {
if !device.excludeMetrics["nv_util"] {
y, err := lp.New("nv_util", device.tags, device.meta, map[string]interface{}{"value": float64(util.Gpu)}, time.Now())
if err == nil {
y.AddMeta("unit", "%")
output <- y
}
}
if !device.excludeMetrics["nv_mem_util"] {
y, err := lp.New("nv_mem_util", device.tags, device.meta, map[string]interface{}{"value": float64(util.Memory)}, time.Now())
if err == nil {
y.AddMeta("unit", "%")
output <- y
}
}
}
}
return nil
}
func readTemp(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
if !device.excludeMetrics["nv_temp"] {
// Retrieves the current temperature readings for the device, in degrees C.
//
// Available temperature sensors:
// * TEMPERATURE_GPU: Temperature sensor for the GPU die.
// * NVML_TEMPERATURE_COUNT
temp, ret := nvml.DeviceGetTemperature(device.device, nvml.TEMPERATURE_GPU)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_temp", device.tags, device.meta, map[string]interface{}{"value": float64(temp)}, time.Now())
if err == nil {
y.AddMeta("unit", "degC")
output <- y
}
}
}
return nil
}
func readFan(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
if !device.excludeMetrics["nv_fan"] {
// Retrieves the intended operating speed of the device's fan.
//
// Note: The reported speed is the intended fan speed.
// If the fan is physically blocked and unable to spin, the output will not match the actual fan speed.
//
// For all discrete products with dedicated fans.
//
// The fan speed is expressed as a percentage of the product's maximum noise tolerance fan speed.
// This value may exceed 100% in certain cases.
fan, ret := nvml.DeviceGetFanSpeed(device.device)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_fan", device.tags, device.meta, map[string]interface{}{"value": float64(fan)}, time.Now())
if err == nil {
y.AddMeta("unit", "%")
output <- y
}
}
}
return nil
}
// func readFans(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
// if !device.excludeMetrics["nv_fan"] {
// numFans, ret := nvml.DeviceGetNumFans(device.device)
// if ret == nvml.SUCCESS {
// for i := 0; i < numFans; i++ {
// fan, ret := nvml.DeviceGetFanSpeed_v2(device.device, i)
// if ret == nvml.SUCCESS {
// y, err := lp.New("nv_fan", device.tags, device.meta, map[string]interface{}{"value": float64(fan)}, time.Now())
// if err == nil {
// y.AddMeta("unit", "%")
// y.AddTag("stype", "fan")
// y.AddTag("stype-id", fmt.Sprintf("%d", i))
// output <- y
// }
// }
// }
// }
// }
// return nil
// }
func readEccMode(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
if !device.excludeMetrics["nv_ecc_mode"] {
// Retrieves the current and pending ECC modes for the device.
//
// For Fermi or newer fully supported devices. Only applicable to devices with ECC.
// Requires NVML_INFOROM_ECC version 1.0 or higher.
//
// Changing ECC modes requires a reboot.
// The "pending" ECC mode refers to the target mode following the next reboot.
_, ecc_pend, ret := nvml.DeviceGetEccMode(device.device)
if ret == nvml.SUCCESS {
var y lp.CCMetric
var err error
switch ecc_pend {
case nvml.FEATURE_DISABLED:
y, err = lp.New("nv_ecc_mode", device.tags, device.meta, map[string]interface{}{"value": "OFF"}, time.Now())
case nvml.FEATURE_ENABLED:
y, err = lp.New("nv_ecc_mode", device.tags, device.meta, map[string]interface{}{"value": "ON"}, time.Now())
default:
y, err = lp.New("nv_ecc_mode", device.tags, device.meta, map[string]interface{}{"value": "UNKNOWN"}, time.Now())
}
if err == nil {
output <- y
}
} else if ret == nvml.ERROR_NOT_SUPPORTED {
y, err := lp.New("nv_ecc_mode", device.tags, device.meta, map[string]interface{}{"value": "N/A"}, time.Now())
if err == nil {
output <- y
}
}
}
return nil
}
func readPerfState(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
if !device.excludeMetrics["nv_perf_state"] {
// Retrieves the current performance state for the device.
//
// Allowed PStates:
// 0: Maximum Performance.
// ..
// 15: Minimum Performance.
// 32: Unknown performance state.
pState, ret := nvml.DeviceGetPerformanceState(device.device)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_perf_state", device.tags, device.meta, map[string]interface{}{"value": fmt.Sprintf("P%d", int(pState))}, time.Now())
if err == nil {
output <- y
}
}
}
return nil
}
func readPowerUsage(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
if !device.excludeMetrics["nv_power_usage"] {
// Retrieves power usage for this GPU in milliwatts and its associated circuitry (e.g. memory)
//
// On Fermi and Kepler GPUs the reading is accurate to within +/- 5% of current power draw.
//
// It is only available if power management mode is supported
mode, ret := nvml.DeviceGetPowerManagementMode(device.device)
if ret != nvml.SUCCESS {
return nil
}
if mode == nvml.FEATURE_ENABLED {
power, ret := nvml.DeviceGetPowerUsage(device.device)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_power_usage", device.tags, device.meta, map[string]interface{}{"value": float64(power) / 1000}, time.Now())
if err == nil {
y.AddMeta("unit", "watts")
output <- y
}
}
}
}
return nil
}
func readClocks(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
// Retrieves the current clock speeds for the device.
//
// Available clock information:
// * CLOCK_GRAPHICS: Graphics clock domain.
// * CLOCK_SM: Streaming Multiprocessor clock domain.
// * CLOCK_MEM: Memory clock domain.
if !device.excludeMetrics["nv_graphics_clock"] {
graphicsClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_GRAPHICS)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_graphics_clock", device.tags, device.meta, map[string]interface{}{"value": float64(graphicsClock)}, time.Now())
if err == nil {
y.AddMeta("unit", "MHz")
output <- y
}
}
}
if !device.excludeMetrics["nv_sm_clock"] {
smCock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_SM)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_sm_clock", device.tags, device.meta, map[string]interface{}{"value": float64(smCock)}, time.Now())
if err == nil {
y.AddMeta("unit", "MHz")
output <- y
}
}
}
if !device.excludeMetrics["nv_mem_clock"] {
memClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_MEM)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_mem_clock", device.tags, device.meta, map[string]interface{}{"value": float64(memClock)}, time.Now())
if err == nil {
y.AddMeta("unit", "MHz")
output <- y
}
}
}
if !device.excludeMetrics["nv_video_clock"] {
memClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_VIDEO)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_video_clock", device.tags, device.meta, map[string]interface{}{"value": float64(memClock)}, time.Now())
if err == nil {
y.AddMeta("unit", "MHz")
output <- y
}
}
}
return nil
}
func readMaxClocks(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
// Retrieves the maximum clock speeds for the device.
//
// Available clock information:
// * CLOCK_GRAPHICS: Graphics clock domain.
// * CLOCK_SM: Streaming multiprocessor clock domain.
// * CLOCK_MEM: Memory clock domain.
// * CLOCK_VIDEO: Video encoder/decoder clock domain.
// * CLOCK_COUNT: Count of clock types.
//
// Note:
/// On GPUs from Fermi family current P0 clocks (reported by nvmlDeviceGetClockInfo) can differ from max clocks by few MHz.
if !device.excludeMetrics["nv_max_graphics_clock"] {
max_gclk, ret := nvml.DeviceGetMaxClockInfo(device.device, nvml.CLOCK_GRAPHICS)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_max_graphics_clock", device.tags, device.meta, map[string]interface{}{"value": float64(max_gclk)}, time.Now())
if err == nil {
y.AddMeta("unit", "MHz")
output <- y
}
}
}
if !device.excludeMetrics["nv_max_sm_clock"] {
maxSmClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_SM)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_max_sm_clock", device.tags, device.meta, map[string]interface{}{"value": float64(maxSmClock)}, time.Now())
if err == nil {
y.AddMeta("unit", "MHz")
output <- y
}
}
}
if !device.excludeMetrics["nv_max_mem_clock"] {
maxMemClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_MEM)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_max_mem_clock", device.tags, device.meta, map[string]interface{}{"value": float64(maxMemClock)}, time.Now())
if err == nil {
y.AddMeta("unit", "MHz")
output <- y
}
}
}
if !device.excludeMetrics["nv_max_video_clock"] {
maxMemClock, ret := nvml.DeviceGetClockInfo(device.device, nvml.CLOCK_VIDEO)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_max_video_clock", device.tags, device.meta, map[string]interface{}{"value": float64(maxMemClock)}, time.Now())
if err == nil {
y.AddMeta("unit", "MHz")
output <- y
}
}
}
return nil
}
func readEccErrors(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
if !device.excludeMetrics["nv_ecc_uncorrected_error"] {
// Retrieves the total ECC error counts for the device.
//
// For Fermi or newer fully supported devices.
// Only applicable to devices with ECC.
// Requires NVML_INFOROM_ECC version 1.0 or higher.
// Requires ECC Mode to be enabled.
//
// The total error count is the sum of errors across each of the separate memory systems,
// i.e. the total set of errors across the entire device.
ecc_db, ret := nvml.DeviceGetTotalEccErrors(device.device, nvml.MEMORY_ERROR_TYPE_UNCORRECTED, nvml.AGGREGATE_ECC)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_ecc_uncorrected_error", device.tags, device.meta, map[string]interface{}{"value": float64(ecc_db)}, time.Now())
if err == nil {
output <- y
}
}
}
if !device.excludeMetrics["nv_ecc_corrected_error"] {
ecc_sb, ret := nvml.DeviceGetTotalEccErrors(device.device, nvml.MEMORY_ERROR_TYPE_CORRECTED, nvml.AGGREGATE_ECC)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_ecc_corrected_error", device.tags, device.meta, map[string]interface{}{"value": float64(ecc_sb)}, time.Now())
if err == nil {
output <- y
}
}
}
return nil
}
func readPowerLimit(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
if !device.excludeMetrics["nv_power_max_limit"] {
// Retrieves the power management limit associated with this device.
//
// For Fermi or newer fully supported devices.
//
// The power limit defines the upper boundary for the card's power draw.
// If the card's total power draw reaches this limit the power management algorithm kicks in.
pwr_limit, ret := nvml.DeviceGetPowerManagementLimit(device.device)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_power_max_limit", device.tags, device.meta, map[string]interface{}{"value": float64(pwr_limit) / 1000}, time.Now())
if err == nil {
y.AddMeta("unit", "watts")
output <- y
}
}
}
return nil
}
func readEncUtilization(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
isMig, ret := nvml.DeviceIsMigDeviceHandle(device.device)
if ret != nvml.SUCCESS {
err := errors.New(nvml.ErrorString(ret))
return err
}
if isMig {
return nil
}
if !device.excludeMetrics["nv_encoder_util"] {
// Retrieves the current utilization and sampling size in microseconds for the Encoder
//
// For Kepler or newer fully supported devices.
//
// Note: On MIG-enabled GPUs, querying encoder utilization is not currently supported.
enc_util, _, ret := nvml.DeviceGetEncoderUtilization(device.device)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_encoder_util", device.tags, device.meta, map[string]interface{}{"value": float64(enc_util)}, time.Now())
if err == nil {
y.AddMeta("unit", "%")
output <- y
}
}
}
return nil
}
func readDecUtilization(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
isMig, ret := nvml.DeviceIsMigDeviceHandle(device.device)
if ret != nvml.SUCCESS {
err := errors.New(nvml.ErrorString(ret))
return err
}
if isMig {
return nil
}
if !device.excludeMetrics["nv_decoder_util"] {
// Retrieves the current utilization and sampling size in microseconds for the Encoder
//
// For Kepler or newer fully supported devices.
//
// Note: On MIG-enabled GPUs, querying encoder utilization is not currently supported.
dec_util, _, ret := nvml.DeviceGetDecoderUtilization(device.device)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_decoder_util", device.tags, device.meta, map[string]interface{}{"value": float64(dec_util)}, time.Now())
if err == nil {
y.AddMeta("unit", "%")
output <- y
}
}
}
return nil
}
func readRemappedRows(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
if !device.excludeMetrics["nv_remapped_rows_corrected"] ||
!device.excludeMetrics["nv_remapped_rows_uncorrected"] ||
!device.excludeMetrics["nv_remapped_rows_pending"] ||
!device.excludeMetrics["nv_remapped_rows_failure"] {
// Get number of remapped rows. The number of rows reported will be based on the cause of the remapping.
// isPending indicates whether or not there are pending remappings.
// A reset will be required to actually remap the row.
// failureOccurred will be set if a row remapping ever failed in the past.
// A pending remapping won't affect future work on the GPU since error-containment and dynamic page blacklisting will take care of that.
//
// For Ampere or newer fully supported devices.
//
// Note: On MIG-enabled GPUs with active instances, querying the number of remapped rows is not supported
corrected, uncorrected, pending, failure, ret := nvml.DeviceGetRemappedRows(device.device)
if ret == nvml.SUCCESS {
if !device.excludeMetrics["nv_remapped_rows_corrected"] {
y, err := lp.New("nv_remapped_rows_corrected", device.tags, device.meta, map[string]interface{}{"value": float64(corrected)}, time.Now())
if err == nil {
output <- y
}
}
if !device.excludeMetrics["nv_remapped_rows_uncorrected"] {
y, err := lp.New("nv_remapped_rows_corrected", device.tags, device.meta, map[string]interface{}{"value": float64(uncorrected)}, time.Now())
if err == nil {
output <- y
}
}
if !device.excludeMetrics["nv_remapped_rows_pending"] {
var p int = 0
if pending {
p = 1
}
y, err := lp.New("nv_remapped_rows_pending", device.tags, device.meta, map[string]interface{}{"value": p}, time.Now())
if err == nil {
output <- y
}
}
if !device.excludeMetrics["nv_remapped_rows_failure"] {
var f int = 0
if failure {
f = 1
}
y, err := lp.New("nv_remapped_rows_failure", device.tags, device.meta, map[string]interface{}{"value": f}, time.Now())
if err == nil {
output <- y
}
}
}
}
return nil
}
func readProcessCounts(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
if !device.excludeMetrics["nv_compute_processes"] {
// Get information about processes with a compute context on a device
//
// For Fermi &tm; or newer fully supported devices.
//
// This function returns information only about compute running processes (e.g. CUDA application which have
// active context). Any graphics applications (e.g. using OpenGL, DirectX) won't be listed by this function.
//
// To query the current number of running compute processes, call this function with *infoCount = 0. The
// return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if none are running. For this call
// \a infos is allowed to be NULL.
//
// The usedGpuMemory field returned is all of the memory used by the application.
//
// Keep in mind that information returned by this call is dynamic and the number of elements might change in
// time. Allocate more space for \a infos table in case new compute processes are spawned.
//
// @note In MIG mode, if device handle is provided, the API returns aggregate information, only if
// the caller has appropriate privileges. Per-instance information can be queried by using
// specific MIG device handles.
// Querying per-instance information using MIG device handles is not supported if the device is in vGPU Host virtualization mode.
procList, ret := nvml.DeviceGetComputeRunningProcesses(device.device)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_compute_processes", device.tags, device.meta, map[string]interface{}{"value": len(procList)}, time.Now())
if err == nil {
output <- y
}
}
}
if !device.excludeMetrics["nv_graphics_processes"] {
// Get information about processes with a graphics context on a device
//
// For Kepler &tm; or newer fully supported devices.
//
// This function returns information only about graphics based processes
// (eg. applications using OpenGL, DirectX)
//
// To query the current number of running graphics processes, call this function with *infoCount = 0. The
// return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if none are running. For this call
// \a infos is allowed to be NULL.
//
// The usedGpuMemory field returned is all of the memory used by the application.
//
// Keep in mind that information returned by this call is dynamic and the number of elements might change in
// time. Allocate more space for \a infos table in case new graphics processes are spawned.
//
// @note In MIG mode, if device handle is provided, the API returns aggregate information, only if
// the caller has appropriate privileges. Per-instance information can be queried by using
// specific MIG device handles.
// Querying per-instance information using MIG device handles is not supported if the device is in vGPU Host virtualization mode.
procList, ret := nvml.DeviceGetGraphicsRunningProcesses(device.device)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_graphics_processes", device.tags, device.meta, map[string]interface{}{"value": len(procList)}, time.Now())
if err == nil {
output <- y
}
}
}
// if !device.excludeMetrics["nv_mps_compute_processes"] {
// // Get information about processes with a MPS compute context on a device
// //
// // For Volta &tm; or newer fully supported devices.
// //
// // This function returns information only about compute running processes (e.g. CUDA application which have
// // active context) utilizing MPS. Any graphics applications (e.g. using OpenGL, DirectX) won't be listed by
// // this function.
// //
// // To query the current number of running compute processes, call this function with *infoCount = 0. The
// // return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if none are running. For this call
// // \a infos is allowed to be NULL.
// //
// // The usedGpuMemory field returned is all of the memory used by the application.
// //
// // Keep in mind that information returned by this call is dynamic and the number of elements might change in
// // time. Allocate more space for \a infos table in case new compute processes are spawned.
// //
// // @note In MIG mode, if device handle is provided, the API returns aggregate information, only if
// // the caller has appropriate privileges. Per-instance information can be queried by using
// // specific MIG device handles.
// // Querying per-instance information using MIG device handles is not supported if the device is in vGPU Host virtualization mode.
// procList, ret := nvml.DeviceGetMPSComputeRunningProcesses(device.device)
// if ret == nvml.SUCCESS {
// y, err := lp.New("nv_mps_compute_processes", device.tags, device.meta, map[string]interface{}{"value": len(procList)}, time.Now())
// if err == nil {
// output <- y
// }
// }
// }
return nil
}
func readViolationStats(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
var violTime nvml.ViolationTime
var ret nvml.Return
// Gets the duration of time during which the device was throttled (lower than requested clocks) due to power
// or thermal constraints.
//
// The method is important to users who are tying to understand if their GPUs throttle at any point during their applications. The
// difference in violation times at two different reference times gives the indication of GPU throttling event.
//
// Violation for thermal capping is not supported at this time.
//
// For Kepler or newer fully supported devices.
if !device.excludeMetrics["nv_violation_power"] {
// How long did power violations cause the GPU to be below application clocks
violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_POWER)
if ret == nvml.SUCCESS {
t := float64(violTime.ViolationTime) * 1e-9
y, err := lp.New("nv_violation_power", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now())
if err == nil {
y.AddMeta("unit", "sec")
output <- y
}
}
}
if !device.excludeMetrics["nv_violation_thermal"] {
// How long did thermal violations cause the GPU to be below application clocks
violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_THERMAL)
if ret == nvml.SUCCESS {
t := float64(violTime.ViolationTime) * 1e-9
y, err := lp.New("nv_violation_thermal", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now())
if err == nil {
y.AddMeta("unit", "sec")
output <- y
}
}
}
if !device.excludeMetrics["nv_violation_sync_boost"] {
// How long did sync boost cause the GPU to be below application clocks
violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_SYNC_BOOST)
if ret == nvml.SUCCESS {
t := float64(violTime.ViolationTime) * 1e-9
y, err := lp.New("nv_violation_sync_boost", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now())
if err == nil {
y.AddMeta("unit", "sec")
output <- y
}
}
}
if !device.excludeMetrics["nv_violation_board_limit"] {
// How long did the board limit cause the GPU to be below application clocks
violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_BOARD_LIMIT)
if ret == nvml.SUCCESS {
t := float64(violTime.ViolationTime) * 1e-9
y, err := lp.New("nv_violation_board_limit", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now())
if err == nil {
y.AddMeta("unit", "sec")
output <- y
}
}
}
if !device.excludeMetrics["nv_violation_low_util"] {
// How long did low utilization cause the GPU to be below application clocks
violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_LOW_UTILIZATION)
if ret == nvml.SUCCESS {
t := float64(violTime.ViolationTime) * 1e-9
y, err := lp.New("nv_violation_low_util", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now())
if err == nil {
y.AddMeta("unit", "sec")
output <- y
}
}
}
if !device.excludeMetrics["nv_violation_reliability"] {
// How long did the board reliability limit cause the GPU to be below application clocks
violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_RELIABILITY)
if ret == nvml.SUCCESS {
t := float64(violTime.ViolationTime) * 1e-9
y, err := lp.New("nv_violation_reliability", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now())
if err == nil {
y.AddMeta("unit", "sec")
output <- y
}
}
}
if !device.excludeMetrics["nv_violation_below_app_clock"] {
// Total time the GPU was held below application clocks by any limiter (all of above)
violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_TOTAL_APP_CLOCKS)
if ret == nvml.SUCCESS {
t := float64(violTime.ViolationTime) * 1e-9
y, err := lp.New("nv_violation_below_app_clock", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now())
if err == nil {
y.AddMeta("unit", "sec")
output <- y
}
}
}
if !device.excludeMetrics["nv_violation_below_base_clock"] {
// Total time the GPU was held below base clocks
violTime, ret = nvml.DeviceGetViolationStatus(device.device, nvml.PERF_POLICY_TOTAL_BASE_CLOCKS)
if ret == nvml.SUCCESS {
t := float64(violTime.ViolationTime) * 1e-9
y, err := lp.New("nv_violation_below_base_clock", device.tags, device.meta, map[string]interface{}{"value": t}, time.Now())
if err == nil {
y.AddMeta("unit", "sec")
output <- y
}
}
}
return nil
}
func readNVLinkStats(device NvidiaCollectorDevice, output chan lp.CCMetric) error {
// Retrieves the specified error counter value
// Please refer to \a nvmlNvLinkErrorCounter_t for error counters that are available
//
// For Pascal &tm; or newer fully supported devices.
for i := 0; i < nvml.NVLINK_MAX_LINKS; i++ {
state, ret := nvml.DeviceGetNvLinkState(device.device, i)
if ret == nvml.SUCCESS {
if state == nvml.FEATURE_ENABLED {
if !device.excludeMetrics["nv_nvlink_crc_errors"] {
// Data link receive data CRC error counter
count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_CRC_DATA)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_nvlink_crc_errors", device.tags, device.meta, map[string]interface{}{"value": count}, time.Now())
if err == nil {
y.AddTag("stype", "nvlink")
y.AddTag("stype-id", fmt.Sprintf("%d", i))
output <- y
}
}
}
if !device.excludeMetrics["nv_nvlink_ecc_errors"] {
// Data link receive data ECC error counter
count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_ECC_DATA)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_nvlink_ecc_errors", device.tags, device.meta, map[string]interface{}{"value": count}, time.Now())
if err == nil {
y.AddTag("stype", "nvlink")
y.AddTag("stype-id", fmt.Sprintf("%d", i))
output <- y
}
}
}
if !device.excludeMetrics["nv_nvlink_replay_errors"] {
// Data link transmit replay error counter
count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_REPLAY)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_nvlink_replay_errors", device.tags, device.meta, map[string]interface{}{"value": count}, time.Now())
if err == nil {
y.AddTag("stype", "nvlink")
y.AddTag("stype-id", fmt.Sprintf("%d", i))
output <- y
}
}
}
if !device.excludeMetrics["nv_nvlink_recovery_errors"] {
// Data link transmit recovery error counter
count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_RECOVERY)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_nvlink_recovery_errors", device.tags, device.meta, map[string]interface{}{"value": count}, time.Now())
if err == nil {
y.AddTag("stype", "nvlink")
y.AddTag("stype-id", fmt.Sprintf("%d", i))
output <- y
}
}
}
if !device.excludeMetrics["nv_nvlink_crc_flit_errors"] {
// Data link receive flow control digit CRC error counter
count, ret := nvml.DeviceGetNvLinkErrorCounter(device.device, i, nvml.NVLINK_ERROR_DL_CRC_FLIT)
if ret == nvml.SUCCESS {
y, err := lp.New("nv_nvlink_crc_flit_errors", device.tags, device.meta, map[string]interface{}{"value": count}, time.Now())
if err == nil {
y.AddTag("stype", "nvlink")
y.AddTag("stype-id", fmt.Sprintf("%d", i))
output <- y
}
}
}
}
}
}
return nil
}
func (m *NvidiaCollector) Read(interval time.Duration, output chan lp.CCMetric) {
var err error
if !m.init {
return
}
readAll := func(device NvidiaCollectorDevice, output chan lp.CCMetric) {
name, ret := nvml.DeviceGetName(device.device)
if ret != nvml.SUCCESS {
name = "NoName"
}
err = readMemoryInfo(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readMemoryInfo for device", name, "failed")
}
err = readUtilization(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readUtilization for device", name, "failed")
}
err = readTemp(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readTemp for device", name, "failed")
}
err = readFan(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readFan for device", name, "failed")
}
err = readEccMode(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readEccMode for device", name, "failed")
}
err = readPerfState(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readPerfState for device", name, "failed")
}
err = readPowerUsage(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readPowerUsage for device", name, "failed")
}
err = readClocks(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readClocks for device", name, "failed")
}
err = readMaxClocks(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readMaxClocks for device", name, "failed")
}
err = readEccErrors(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readEccErrors for device", name, "failed")
}
err = readPowerLimit(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readPowerLimit for device", name, "failed")
}
err = readEncUtilization(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readEncUtilization for device", name, "failed")
}
err = readDecUtilization(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readDecUtilization for device", name, "failed")
}
err = readRemappedRows(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readRemappedRows for device", name, "failed")
}
err = readBarMemoryInfo(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readBarMemoryInfo for device", name, "failed")
}
err = readProcessCounts(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readProcessCounts for device", name, "failed")
}
err = readViolationStats(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readViolationStats for device", name, "failed")
}
err = readNVLinkStats(device, output)
if err != nil {
cclog.ComponentDebug(m.name, "readNVLinkStats for device", name, "failed")
}
}
// Actual read loop over all attached Nvidia GPUs
for i := 0; i < m.num_gpus; i++ {
readAll(m.gpus[i], output)
// Iterate over all MIG devices if any
if m.config.ProcessMigDevices {
current, _, ret := nvml.DeviceGetMigMode(m.gpus[i].device)
if ret != nvml.SUCCESS {
continue
}
if current == nvml.DEVICE_MIG_DISABLE {
continue
}
maxMig, ret := nvml.DeviceGetMaxMigDeviceCount(m.gpus[i].device)
if ret != nvml.SUCCESS {
continue
}
if maxMig == 0 {
continue
}
cclog.ComponentDebug(m.name, "Reading MIG devices for GPU", i)
for j := 0; j < maxMig; j++ {
mdev, ret := nvml.DeviceGetMigDeviceHandleByIndex(m.gpus[i].device, j)
if ret != nvml.SUCCESS {
continue
}
excludeMetrics := make(map[string]bool)
for _, metric := range m.config.ExcludeMetrics {
excludeMetrics[metric] = true
}
migDevice := NvidiaCollectorDevice{
device: mdev,
tags: map[string]string{},
meta: map[string]string{},
excludeMetrics: excludeMetrics,
}
for k, v := range m.gpus[i].tags {
migDevice.tags[k] = v
}
migDevice.tags["stype"] = "mig"
if m.config.UseUuidForMigDevices {
uuid, ret := nvml.DeviceGetUUID(mdev)
if ret != nvml.SUCCESS {
cclog.ComponentError(m.name, "Unable to get UUID for mig device at index", j, ":", err.Error())
} else {
migDevice.tags["stype-id"] = uuid
}
} else if m.config.UseSliceForMigDevices {
name, ret := nvml.DeviceGetName(m.gpus[i].device)
if ret == nvml.SUCCESS {
mname, ret := nvml.DeviceGetName(mdev)
if ret == nvml.SUCCESS {
x := strings.Replace(mname, name, "", -1)
x = strings.Replace(x, "MIG", "", -1)
x = strings.TrimSpace(x)
migDevice.tags["stype-id"] = x
}
}
}
if _, ok := migDevice.tags["stype-id"]; !ok {
migDevice.tags["stype-id"] = fmt.Sprintf("%d", j)
}
for k, v := range m.gpus[i].meta {
migDevice.meta[k] = v
}
if _, ok := migDevice.meta["uuid"]; ok && !m.config.UseUuidForMigDevices {
uuid, ret := nvml.DeviceGetUUID(mdev)
if ret == nvml.SUCCESS {
migDevice.meta["uuid"] = uuid
}
}
readAll(migDevice, output)
}
}
}
}
func (m *NvidiaCollector) Close() {
if m.init {
nvml.Shutdown()
m.init = false
}
}
|
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.
package engine
import (
"testing"
"github.com/Azure/go-autorest/autorest/to"
"github.com/google/go-cmp/cmp"
"github.com/Azure/aks-engine/pkg/api"
"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-12-01/compute"
)
func TestCreateAvailabilitySet(t *testing.T) {
//Test AvSet without ManagedDisk
cs := &api.ContainerService{
Properties: &api.Properties{
MasterProfile: &api.MasterProfile{
AvailabilityZones: []string{},
},
},
}
avSet := CreateAvailabilitySet(cs, false)
expectedAvSet := AvailabilitySetARM{
ARMResource: ARMResource{
APIVersion: "[variables('apiVersionCompute')]",
},
AvailabilitySet: compute.AvailabilitySet{
Name: to.StringPtr("[variables('masterAvailabilitySet')]"),
Location: to.StringPtr("[variables('location')]"),
Type: to.StringPtr("Microsoft.Compute/availabilitySets"),
},
}
diff := cmp.Diff(avSet, expectedAvSet)
if diff != "" {
t.Errorf("unexpected error while comparing availability sets: %s", diff)
}
//Test AvSet with ManagedDisk
cs = &api.ContainerService{
Properties: &api.Properties{
MasterProfile: &api.MasterProfile{
PlatformUpdateDomainCount: to.IntPtr(3),
},
},
}
avSet = CreateAvailabilitySet(cs, true)
expectedAvSet = AvailabilitySetARM{
ARMResource: ARMResource{
APIVersion: "[variables('apiVersionCompute')]",
},
AvailabilitySet: compute.AvailabilitySet{
Name: to.StringPtr("[variables('masterAvailabilitySet')]"),
Location: to.StringPtr("[variables('location')]"),
Type: to.StringPtr("Microsoft.Compute/availabilitySets"),
Sku: &compute.Sku{
Name: to.StringPtr("Aligned"),
},
AvailabilitySetProperties: &compute.AvailabilitySetProperties{
PlatformUpdateDomainCount: to.Int32Ptr(3),
},
},
}
diff = cmp.Diff(avSet, expectedAvSet)
if diff != "" {
t.Errorf("unexpected error while comparing availability sets: %s", diff)
}
//Test AvSet with StorageAccount
cs = &api.ContainerService{
Properties: &api.Properties{
MasterProfile: &api.MasterProfile{
StorageProfile: api.StorageAccount,
},
},
}
avSet = CreateAvailabilitySet(cs, false)
expectedAvSet = AvailabilitySetARM{
ARMResource: ARMResource{
APIVersion: "[variables('apiVersionCompute')]",
},
AvailabilitySet: compute.AvailabilitySet{
Name: to.StringPtr("[variables('masterAvailabilitySet')]"),
Location: to.StringPtr("[variables('location')]"),
Type: to.StringPtr("Microsoft.Compute/availabilitySets"),
AvailabilitySetProperties: &compute.AvailabilitySetProperties{},
},
}
diff = cmp.Diff(avSet, expectedAvSet)
if diff != "" {
t.Errorf("unexpected error while comparing availability sets: %s", diff)
}
// Test availability set with platform fault domain+update count set
count := 3
cs = &api.ContainerService{
Properties: &api.Properties{
MasterProfile: &api.MasterProfile{
PlatformFaultDomainCount: &count,
PlatformUpdateDomainCount: &count,
},
},
}
avSet = CreateAvailabilitySet(cs, true)
expectedAvSet = AvailabilitySetARM{
ARMResource: ARMResource{
APIVersion: "[variables('apiVersionCompute')]",
},
AvailabilitySet: compute.AvailabilitySet{
Name: to.StringPtr("[variables('masterAvailabilitySet')]"),
Location: to.StringPtr("[variables('location')]"),
Type: to.StringPtr("Microsoft.Compute/availabilitySets"),
Sku: &compute.Sku{
Name: to.StringPtr("Aligned"),
},
AvailabilitySetProperties: &compute.AvailabilitySetProperties{
PlatformFaultDomainCount: to.Int32Ptr(int32(count)),
PlatformUpdateDomainCount: to.Int32Ptr(3),
},
},
}
diff = cmp.Diff(avSet, expectedAvSet)
if diff != "" {
t.Errorf("unexpected error while comparing availability sets: %s", diff)
}
}
func TestCreateAgentAvailabilitySets(t *testing.T) {
//Test AvSet without ManagedDisk
profile := &api.AgentPoolProfile{
Name: "foobar",
StorageProfile: api.StorageAccount,
}
avSet := createAgentAvailabilitySets(profile)
expectedAvSet := AvailabilitySetARM{
ARMResource: ARMResource{
APIVersion: "[variables('apiVersionCompute')]",
},
AvailabilitySet: compute.AvailabilitySet{
Name: to.StringPtr("[variables('foobarAvailabilitySet')]"),
Location: to.StringPtr("[variables('location')]"),
Type: to.StringPtr("Microsoft.Compute/availabilitySets"),
AvailabilitySetProperties: &compute.AvailabilitySetProperties{},
},
}
diff := cmp.Diff(avSet, expectedAvSet)
if diff != "" {
t.Errorf("unexpected error while comparing availability sets: %s", diff)
}
//Test AvSet wit ManagedDisk
profile = &api.AgentPoolProfile{
Name: "foobar",
StorageProfile: api.ManagedDisks,
PlatformUpdateDomainCount: to.IntPtr(3),
}
avSet = createAgentAvailabilitySets(profile)
expectedAvSet = AvailabilitySetARM{
ARMResource: ARMResource{
APIVersion: "[variables('apiVersionCompute')]",
},
AvailabilitySet: compute.AvailabilitySet{
Name: to.StringPtr("[variables('foobarAvailabilitySet')]"),
Location: to.StringPtr("[variables('location')]"),
Type: to.StringPtr("Microsoft.Compute/availabilitySets"),
AvailabilitySetProperties: &compute.AvailabilitySetProperties{
PlatformUpdateDomainCount: to.Int32Ptr(3),
},
Sku: &compute.Sku{
Name: to.StringPtr("Aligned"),
},
},
}
diff = cmp.Diff(avSet, expectedAvSet)
if diff != "" {
t.Errorf("unexpected error while comparing availability sets: %s", diff)
}
// Test availability set with platform fault+update domain count set
count := 3
profile = &api.AgentPoolProfile{
Name: "foobar",
StorageProfile: api.ManagedDisks,
PlatformFaultDomainCount: &count,
PlatformUpdateDomainCount: &count,
}
avSet = createAgentAvailabilitySets(profile)
expectedAvSet = AvailabilitySetARM{
ARMResource: ARMResource{
APIVersion: "[variables('apiVersionCompute')]",
},
AvailabilitySet: compute.AvailabilitySet{
Name: to.StringPtr("[variables('foobarAvailabilitySet')]"),
Location: to.StringPtr("[variables('location')]"),
Type: to.StringPtr("Microsoft.Compute/availabilitySets"),
AvailabilitySetProperties: &compute.AvailabilitySetProperties{
PlatformFaultDomainCount: to.Int32Ptr(int32(count)),
PlatformUpdateDomainCount: to.Int32Ptr(3),
},
Sku: &compute.Sku{
Name: to.StringPtr("Aligned"),
},
},
}
diff = cmp.Diff(avSet, expectedAvSet)
if diff != "" {
t.Errorf("unexpected error while comparing availability sets: %s", diff)
}
}
|
/*
Copyright 2021 The KubeVela 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 client
import (
"context"
sdkcommon "github.com/kubevela/vela-go-sdk/pkg/apis/common"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/client-go/rest"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/client/config"
"github.com/oam-dev/kubevela-core-api/apis/core.oam.dev/v1beta1"
"github.com/kubevela/vela-go-sdk/pkg/apis"
)
var schema *runtime.Scheme
type Client interface {
Get(ctx context.Context, key client.ObjectKey) (apis.TypedApplication, error)
List(ctx context.Context, opts client.ListOption) ([]apis.TypedApplication, error)
Create(ctx context.Context, app apis.TypedApplication) error
Delete(ctx context.Context, app apis.TypedApplication) error
Update(ctx context.Context, app apis.TypedApplication) error
Patch(ctx context.Context, app apis.TypedApplication, patch client.Patch) error
}
type clientImpl struct {
clt client.Client
}
func init() {
schema = runtime.NewScheme()
_ = v1beta1.AddToScheme(schema)
}
func NewFromClient(clt client.Client) Client {
return &clientImpl{clt: clt}
}
func New(config *rest.Config) (Client, error) {
clt, err := client.New(config, client.Options{Scheme: schema})
if err != nil {
return nil, err
}
return NewFromClient(clt), nil
}
func NewDefault() (Client, error) {
restConf, err := config.GetConfig()
if err != nil {
return nil, err
}
return New(restConf)
}
func NewDefaultOrDie() Client {
restConf, err := config.GetConfig()
if err != nil {
panic(err)
}
clt, err := New(restConf)
if err != nil {
panic(err)
}
return clt
}
func NewFromConfigWithOptions(config *rest.Config, options client.Options) (Client, error) {
clt, err := client.New(config, options)
if err != nil {
return nil, err
}
return NewFromClient(clt), nil
}
func (c clientImpl) Get(ctx context.Context, key client.ObjectKey) (apis.TypedApplication, error) {
_app := v1beta1.Application{}
err := c.clt.Get(ctx, key, &_app)
if err != nil {
return nil, err
}
return sdkcommon.FromK8sObject(_app)
}
func (c clientImpl) List(ctx context.Context, opts client.ListOption) ([]apis.TypedApplication, error) {
_appList := &v1beta1.ApplicationList{}
err := c.clt.List(ctx, _appList, opts)
if err != nil {
return nil, err
}
var apps []apis.TypedApplication
for _, app := range _appList.Items {
_app, err := sdkcommon.FromK8sObject(app)
if err != nil {
return nil, err
}
apps = append(apps, _app)
}
return apps, nil
}
func (c clientImpl) Create(ctx context.Context, app apis.TypedApplication) error {
appObj := app.Build()
return c.clt.Create(ctx, &appObj)
}
func (c clientImpl) Delete(ctx context.Context, app apis.TypedApplication) error {
appObj := app.Build()
return c.clt.Delete(ctx, &appObj)
}
func (c clientImpl) Update(ctx context.Context, app apis.TypedApplication) error {
appObj := app.Build()
return c.clt.Update(ctx, &appObj)
}
func (c clientImpl) Patch(ctx context.Context, app apis.TypedApplication, patch client.Patch) error {
appObj := app.Build()
return c.clt.Patch(ctx, &appObj, patch)
}
|
package gcp
import (
"testing"
"github.com/stretchr/testify/assert"
)
func Test_policyMemberToEmail(t *testing.T) {
cases := []struct {
member string
email string
}{{
member: "serviceAccount:operator@project",
email: "operator@project",
}, {
member: "deleted:serviceAccount:operator@project",
email: "operator@project",
}, {
member: "deleted:serviceAccount:operator@project?uid=1231243234",
email: "operator@project",
}, {
member: "user:user@project",
email: "user:user@project",
}, {
member: "deleted:user:user@project",
email: "user:user@project",
}, {
member: "deleted:user:user@project?uid=1232131243",
email: "user:user@project",
}}
for _, test := range cases {
t.Run("", func(t *testing.T) {
email := policyMemberToEmail(test.member)
assert.Equal(t, email, test.email)
})
}
}
|
package chain
import (
"context"
"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/accounts/abi"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/core/types"
"github.com/google/uuid"
"github.com/sanguohot/medichain/contracts/medi"
"github.com/sanguohot/medichain/datacenter"
"github.com/sanguohot/medichain/etc"
"github.com/sanguohot/medichain/util"
"math/big"
"strings"
)
var addFileEventName = "onAddFile"
func ChainGetFileAddLogList(fromBlock int64, toBlock int64) (error, []datacenter.FileAddLog) {
client, err := GetEthDialClient()
if err != nil {
return err, nil
}
err, address := GetAddressFromCns(etc.ContractFilesData)
if err != nil {
return err, nil
}
query := ethereum.FilterQuery{
FromBlock: big.NewInt(fromBlock),
ToBlock: big.NewInt(toBlock),
Addresses: []common.Address{
*address,
},
}
logs, err := client.FilterLogs(context.Background(), query)
if err != nil {
return err, nil
}
contractAbi, err := abi.JSON(strings.NewReader(string(medi.FilesDataABI)))
if err != nil {
return err, nil
}
var addFileTopic *common.Hash
for _, item := range contractAbi.Events {
if item.Name == addFileEventName {
hash := item.Id()
addFileTopic = &hash
}
}
if addFileTopic == nil {
return util.ErrMatchLogNotFound, nil
}
return rangeLogsToGetFileAddLogList(contractAbi, *address, logs, *addFileTopic)
}
func rangeLogsToGetFileAddLogList(contractAbi abi.ABI, address common.Address, logs []types.Log, topic common.Hash) (error, []datacenter.FileAddLog) {
fl := []datacenter.FileAddLog{}
for _, log := range logs {
found := false
for _, item := range log.Topics {
if item == topic {
found = true
break
}
}
if !found {
continue
}
err, f := parseEventToFileAddLog(contractAbi, address, log)
if err != nil {
return err, nil
}
fl = append(fl, *f)
}
return nil, fl
}
func parseEventToFileAddLog(contractAbi abi.ABI, address common.Address, log types.Log) (error, *datacenter.FileAddLog) {
var event struct {
Uuid [16]byte
OwnerUuid [16]byte
UploaderUuid [16]byte
OrgUuid [16]byte
FileType [32]byte
FileDesc [4][32]byte
Keccak256Hash [32]byte
Sha256Hash [32]byte
R [32]byte
S [32]byte
V uint8
Time *big.Int
}
// 参数一是事件参数构造的对象
// 参数二是事件函数名，不是合约函数名
// 参数三是事件的数据
err := contractAbi.Unpack(&event, addFileEventName, log.Data)
if err != nil {
return err, nil
}
fileUuid := uuid.UUID(event.Uuid)
ownerUuid := uuid.UUID(event.OwnerUuid)
uploaderUuid := uuid.UUID(event.UploaderUuid)
orgUuid := uuid.UUID(event.OrgUuid)
fileTypeHash := common.Hash(event.FileType)
fileDesc := util.Bytes32_4ToString(event.FileDesc)
keccak256Hash := common.Hash(event.Keccak256Hash)
sha256Hash := common.Hash(event.Sha256Hash)
r := common.Hash(event.R)
s := common.Hash(event.S)
signature := util.RSVtoSig(r, s, event.V)
signers := uploaderUuid
f := datacenter.FileAddLog {
FileUuid: fileUuid.String(),
OwnerUuid: ownerUuid.String(),
UploaderUuid: uploaderUuid.String(),
OrgUuid: orgUuid.String(),
FileTypeHash: fileTypeHash.Hex(),
FileType: etc.FileTypeMap[fileTypeHash],
FileDesc: fileDesc,
Keccak256Hash: keccak256Hash.Hex(),
Sha256Hash: sha256Hash.Hex(),
CreateTime: event.Time.Uint64(),
Signature: hexutil.Encode(signature)[2:],
Signer: signers.String(),
BlockNum: log.BlockNumber,
BlockHash: log.BlockHash.Hex(),
TransactionHash: log.TxHash.Hex(),
ContractAddress: address.Hex(),
}
return nil, &f
}
func ChainGetFileAddLogListAll() (error, []datacenter.FileAddLog) {
client, err := GetEthDialClient()
if err != nil {
return err, nil
}
header, err := client.HeaderByNumber(context.Background(), nil)
if err != nil {
return err, nil
}
err, max := datacenter.SqliteGetFileAddLogMaxBlockNum()
if err != nil {
return err, nil
}
if max >= header.Number.Uint64() {
return nil, []datacenter.FileAddLog{}
}
return ChainGetFileAddLogList(int64(max+1), header.Number.Int64())
}
|
package postgis
import (
"errors"
"fmt"
"strings"
"database/sql"
gostErrors "github.com/geodan/gost/src/errors"
"github.com/geodan/gost/src/sensorthings/entities"
"github.com/geodan/gost/src/sensorthings/odata"
)
func observationParamFactory(values map[string]interface{}) (entities.Entity, error) {
o := &entities.Observation{}
for as, value := range values {
if value == nil {
continue
}
if as == asMappings[entities.EntityTypeObservation][observationID] {
o.ID = value
}
if as == asMappings[entities.EntityTypeObservation][observationPhenomenonTime] {
o.PhenomenonTime = value.(string)
}
if as == asMappings[entities.EntityTypeObservation][observationResultTime] {
o.ResultTime = value.(string)
}
if as == asMappings[entities.EntityTypeObservation][observationResult] {
o.Result = value
}
if as == asMappings[entities.EntityTypeObservation][observationValidTime] {
o.ValidTime = value.(string)
}
if as == asMappings[entities.EntityTypeObservation][observationResultQuality] {
o.ResultQuality = value.(string)
}
if as == asMappings[entities.EntityTypeObservation][observationParameters] {
t := value.(string)
parameterMap, err := JSONToMap(&t)
if err != nil {
return nil, err
}
o.Parameters = parameterMap
}
}
return o, nil
}
// observationParamFactory is used to construct a WHERE clause from an ODATA $select string
func observationParamFactoryWhere(key string, value interface{}) (string, string, error) {
val := fmt.Sprintf("%v", value)
jsonVal := convertSelectValueForJSON(val)
switch key {
case "id":
return "id", val, nil
break
case "phenomenonTime":
return "data -> 'phenomenonTime'", jsonVal, nil
break
case "resultTime":
return "data -> 'resultTime'", jsonVal, nil
break
case "result":
return "data -> 'result'", jsonVal, nil
break
case "resultQuality":
return "data -> 'resultQuality'", jsonVal, nil
break
case "parameters": //implement parameters/parameterName
return "data -> 'parameters'", jsonVal, nil
break
}
return "", "", fmt.Errorf("Parameter %s not implemented", key)
}
func convertSelectValueForJSON(value string) string {
if strings.HasPrefix(value, "'") && strings.HasSuffix(value, "'") {
return value
}
return fmt.Sprintf("'%v'", value)
}
// GetObservation retrieves an observation by id from the database
func (gdb *GostDatabase) GetObservation(id interface{}, qo *odata.QueryOptions) (*entities.Observation, error) {
intID, ok := ToIntID(id)
if !ok {
return nil, gostErrors.NewRequestNotFound(errors.New("Observation does not exist"))
}
sql := fmt.Sprintf("select id, data FROM %s.observation where id = %v ", gdb.Schema, intID)
observation, err := processObservation(gdb.Db, sql, qo)
if err != nil {
return nil, err
}
return observation, nil
}
// GetObservations retrieves all datastreams
func (gdb *GostDatabase) GetObservations(qo *odata.QueryOptions) ([]*entities.Observation, int, error) {
var queryString string
var err error
if queryString, err = CreateFilterQueryString(qo, observationParamFactoryWhere, "WHERE "); err != nil {
return nil, 0, gostErrors.NewBadRequestError(err)
}
sql := fmt.Sprintf("select id, data FROM %s.observation "+queryString+"order by id desc"+CreateTopSkipQueryString(qo), gdb.Schema)
countSQL := fmt.Sprintf("select COUNT(*) FROM %s.observation", gdb.Schema)
return processObservations(gdb.Db, sql, qo, countSQL)
}
// GetObservationsByFeatureOfInterest retrieves all observations by the given FeatureOfInterest id
func (gdb *GostDatabase) GetObservationsByFeatureOfInterest(foiID interface{}, qo *odata.QueryOptions) ([]*entities.Observation, int, error) {
intID, ok := ToIntID(foiID)
if !ok {
return nil, 0, gostErrors.NewRequestNotFound(errors.New("FeatureOfInterest does not exist"))
}
sql := fmt.Sprintf("select id, data FROM %s.observation where featureofinterest_id = %v order by id desc"+CreateTopSkipQueryString(qo), gdb.Schema, intID)
countSQL := fmt.Sprintf("select COUNT(*) FROM %s.observation where featureofinterest_id = %v", gdb.Schema, intID)
return processObservations(gdb.Db, sql, qo, countSQL)
}
// GetObservationsByDatastream retrieves all observations by the given datastream id
func (gdb *GostDatabase) GetObservationsByDatastream(dataStreamID interface{}, qo *odata.QueryOptions) ([]*entities.Observation, int, error) {
var intID int
var queryString string
var ok bool
var err error
if intID, ok = ToIntID(dataStreamID); !ok {
return nil, 0, gostErrors.NewRequestNotFound(errors.New("Datastream does not exist"))
}
if queryString, err = CreateFilterQueryString(qo, observationParamFactoryWhere, " AND "); err != nil {
return nil, 0, gostErrors.NewBadRequestError(errors.New("Datastream does not exist"))
}
sql := fmt.Sprintf("select id, data FROM %s.observation where stream_id = %v "+queryString+"order by id desc"+CreateTopSkipQueryString(qo), gdb.Schema, intID)
countSQL := fmt.Sprintf("select COUNT(*) FROM %s.observation where stream_id = %v", gdb.Schema, intID)
return processObservations(gdb.Db, sql, qo, countSQL)
}
func processObservation(db *sql.DB, sql string, qo *odata.QueryOptions) (*entities.Observation, error) {
observations, _, err := processObservations(db, sql, qo, "")
if err != nil {
return nil, err
}
if len(observations) == 0 {
return nil, gostErrors.NewRequestNotFound(errors.New("Observation not found"))
}
return observations[0], nil
}
func processObservations(db *sql.DB, sql string, qo *odata.QueryOptions, countSQL string) ([]*entities.Observation, int, error) {
rows, err := db.Query(sql)
defer rows.Close()
if err != nil {
return nil, 0, err
}
var observations = []*entities.Observation{}
for rows.Next() {
var id int
var data string
err := rows.Scan(&id, &data)
if err != nil {
return nil, 0, err
}
observation := entities.Observation{}
observation.ID = id
err = observation.ParseEntity([]byte(data))
if err != nil {
return nil, 0, err
}
if qo != nil && qo.QuerySelect != nil && len(qo.QuerySelect.Params) > 0 {
set := make(map[string]bool)
for _, v := range qo.QuerySelect.Params {
set[strings.ToLower(v)] = true
}
_, ok := set["id"]
if !ok {
observation.ID = nil
}
_, ok = set["phenomenontime"]
if !ok {
observation.PhenomenonTime = ""
}
_, ok = set["result"]
if !ok {
observation.Result = nil
}
_, ok = set["resulttime"]
if !ok {
observation.ResultTime = ""
}
_, ok = set["resultquality"]
if !ok {
observation.ResultQuality = ""
}
_, ok = set["validtime"]
if !ok {
observation.ValidTime = ""
}
_, ok = set["parameters"]
if !ok {
observation.Parameters = nil
}
}
observations = append(observations, &observation)
}
var count int
if len(countSQL) > 0 {
db.QueryRow(countSQL).Scan(&count)
}
return observations, count, nil
}
// PutObservation replaces an observation to the database
func (gdb *GostDatabase) PutObservation(id interface{}, o *entities.Observation) (*entities.Observation, error) {
return gdb.PatchObservation(id, o)
/*var err error
var ok bool
var intID, dID, fID int
if intID, ok = ToIntID(id); !ok || !gdb.ObservationExists(intID) {
return nil, gostErrors.NewRequestNotFound(errors.New("Observation does not exist"))
}
if dID, ok = ToIntID(o.Datastream.ID); !ok || !gdb.ObservationExists(dID) {
return nil, gostErrors.NewRequestNotFound(errors.New("Datastream does not exist"))
}
if fID, ok = ToIntID(o.FeatureOfInterest.ID); !ok || !gdb.FeatureOfInterestExists(fID) {
return nil, gostErrors.NewRequestNotFound(errors.New("FeatureOfInterest does not exist"))
}
json, _ := o.MarshalPostgresJSON()
obs := fmt.Sprintf("'%s'", string(json[:]))
sql := fmt.Sprintf("update %s.observation set data=%v, stream_id=%v, featureofinterest_id=%v where id=%v", gdb.Schema, obs, dID, fID, intID)
_, err2 := gdb.Db.Exec(sql)
if err2 != nil {
return nil, err
}
o.ID = intID
return o, nil
*/
}
// PostObservation adds an observation to the database
func (gdb *GostDatabase) PostObservation(o *entities.Observation) (*entities.Observation, error) {
var oID int
dID, ok := ToIntID(o.Datastream.ID)
if !ok {
return nil, gostErrors.NewBadRequestError(errors.New("Datastream does not exist"))
}
if o.FeatureOfInterest == nil || len(fmt.Sprintf("%v", o.FeatureOfInterest.ID)) == 0 {
return nil, gostErrors.NewBadRequestError(errors.New("No FeatureOfInterest supplied or Location found on linked thing"))
}
fID := o.FeatureOfInterest.ID
json, _ := o.MarshalPostgresJSON()
obs := fmt.Sprintf("'%s'", string(json[:]))
sql := fmt.Sprintf("INSERT INTO %s.observation (data, stream_id, featureofinterest_id) VALUES (%v, %v, %v) RETURNING id", gdb.Schema, obs, dID, fID)
err := gdb.Db.QueryRow(sql).Scan(&oID)
if err != nil {
errString := fmt.Sprintf("%v", err.Error())
if strings.Contains(errString, "violates foreign key constraint \"fk_datastream\"") {
return nil, gostErrors.NewBadRequestError(errors.New("Datastream does not exist"))
}
if strings.Contains(errString, "violates foreign key constraint \"fk_featureofinterest\"") {
return nil, gostErrors.NewBadRequestError(errors.New("FeatureOfInterest does not exist"))
}
return nil, err
}
o.ID = oID
if o.ResultTime == "NULL" {
o.ResultTime = ""
}
// clear inner entities to serves links upon response
o.Datastream = nil
o.FeatureOfInterest = nil
return o, nil
}
// ObservationExists checks if an Observation is present in the database based on a given id.
func (gdb *GostDatabase) ObservationExists(id interface{}) bool {
return EntityExists(gdb, id, "observation")
}
// PatchObservation updates a Observation in the database
func (gdb *GostDatabase) PatchObservation(id interface{}, o *entities.Observation) (*entities.Observation, error) {
var err error
var ok bool
var intID int
updates := make(map[string]interface{})
if intID, ok = ToIntID(id); !ok || !gdb.ObservationExists(intID) {
return nil, gostErrors.NewRequestNotFound(errors.New("Observation does not exist"))
}
observation, _ := gdb.GetObservation(intID, nil)
if len(o.PhenomenonTime) > 0 {
observation.PhenomenonTime = o.PhenomenonTime
}
if o.Result != nil {
observation.Result = o.Result
}
if len(o.ResultTime) > 0 {
observation.ResultTime = o.ResultTime
}
if len(o.ResultQuality) > 0 {
observation.ResultQuality = o.ResultQuality
}
if len(o.ValidTime) > 0 {
observation.ValidTime = o.ValidTime
}
if len(o.Parameters) > 0 {
observation.Parameters = o.Parameters
}
json, _ := observation.MarshalPostgresJSON()
updates["data"] = string(json[:])
if err = gdb.updateEntityColumns("observation", updates, intID); err != nil {
return nil, err
}
return observation, nil
}
// DeleteObservation tries to delete a Observation by the given id
func (gdb *GostDatabase) DeleteObservation(id interface{}) error {
return DeleteEntity(gdb, id, "observation")
}
|
package defaults
import (
"github.com/openshift/installer/pkg/types/nutanix"
)
// SetPlatformDefaults sets the defaults for the platform.
func SetPlatformDefaults(p *nutanix.Platform) {}
|
package targzhelper
import (
"archive/tar"
"compress/gzip"
"fmt"
"io"
"os"
"path/filepath"
"strings"
)
func extractFile(header tar.Header, reader io.Reader, path string) (rerr error) {
fileName := filepath.Join(path, header.Name)
file, ferr := os.OpenFile(fileName, os.O_CREATE|os.O_RDWR, header.FileInfo().Mode())
defer func() {
err := file.Close()
fmt.Errorf("error while closing the file %s", err)
}()
if ferr != nil {
return ferr
}
_, err := io.Copy(file, reader)
if err != nil {
return err
}
return nil
}
func extractDir(header tar.Header, reader io.Reader, path string) error {
dirName := filepath.Join(path, header.Name)
err := os.MkdirAll(dirName, header.FileInfo().Mode())
if err != nil {
return err
}
return nil
}
func Untar(reader io.Reader, path string) error {
gzipReader, err := gzip.NewReader(reader)
if err != nil {
return err
}
defer func() {
err := gzipReader.Close()
fmt.Errorf("error closing the reader %s", err)
}()
tarReader := tar.NewReader(gzipReader)
for header, err := tarReader.Next(); err != io.EOF; header, err = tarReader.Next() {
if err != nil {
return err
}
extract := extractFile
if header.FileInfo().IsDir() {
extract = extractDir
}
if err := extract(*header, tarReader, path); err != nil {
return err
}
}
return nil
}
func contains(collection []string, text string) bool {
for index := range collection {
if collection[index] == text {
return true
}
}
return false
}
func hasParentIn(parentCandidates []string, childPath string) bool {
for index := range parentCandidates {
if isParentOf(parentCandidates[index], childPath) {
return true
}
}
return false
}
func isParentOf(parentDir string, pathToCheck string) bool {
return strings.HasPrefix(pathToCheck, parentDir+"/")
}
func MakeTar(path string, writer io.Writer, pathToIgnore []string) error {
fileInfo, err := os.Stat(path)
if err != nil {
return fmt.Errorf("Invalid Path %s", err.Error())
}
if !fileInfo.IsDir() {
return fmt.Errorf("%s is not a directory", path)
}
gzWriter := gzip.NewWriter(writer)
defer gzWriter.Close()
tarWriter := tar.NewWriter(gzWriter)
defer tarWriter.Close()
return filepath.Walk(path, func(fileName string, fileInfo os.FileInfo, err error) error {
if err != nil {
return fmt.Errorf("during walk %s", err)
}
header, err := tar.FileInfoHeader(fileInfo, fileInfo.Name())
if err != nil {
return fmt.Errorf("invalid file header %s", err)
}
header.Name = strings.TrimPrefix(strings.Replace(fileName, path, "", -1), string(filepath.Separator))
if contains(pathToIgnore, header.Name) {
return nil
}
if hasParentIn(pathToIgnore, header.Name) {
return nil
}
if header.Name == "" {
return nil
}
if err := tarWriter.WriteHeader(header); err != nil {
return err
}
if !fileInfo.Mode().IsRegular() {
return nil
}
file, err := os.Open(fileName)
defer func() {
err := file.Close()
fmt.Errorf("error while closing the file %s", err)
}()
if err != nil {
return err
}
if _, err := io.Copy(tarWriter, file); err != nil {
return err
}
return nil
})
}
|
package main
import (
"fmt"
)
const (
lseed = 516
rseed = 190
lfactor = 16807
rfactor = 48271
divisor = 2147483647
maxvals = 5000000
bitmask = 65535
lmultiple = 4
rmultiple = 8
)
func genNext(val int, factor int, multiple int) int {
retVal := (val * factor) % divisor
for (retVal % multiple) != 0 {
retVal = (retVal * factor) % divisor
}
return retVal
}
func main() {
sum := 0
lval := lseed
rval := rseed
for i := 0; i < maxvals; i++ {
lval = genNext(lval, lfactor, lmultiple)
rval = genNext(rval, rfactor, rmultiple)
if lval & bitmask == rval & bitmask {
sum++
}
}
fmt.Println(sum)
}
|
package main
import (
"errors"
"flag"
"github.com/guoyk93/deployer/pkg/tempfile"
"log"
"os"
"path"
"strings"
)
var (
opts Options
optOnlyBuild bool
optOnlyDeploy bool
optSkipDeploy bool
optKeepGenerated bool
)
func sanitize(strs ...*string) {
for _, str := range strs {
val := strings.ReplaceAll(
strings.TrimSpace(strings.ToLower(*str)),
"_", "-")
*str = val
}
}
func fill(input string, out *string) {
*out = strings.TrimSpace(*out)
if len(*out) == 0 {
*out = input
}
}
func missing(str *string, err *error, desc string) bool {
*str = strings.TrimSpace(*str)
if len(*str) == 0 {
*err = errors.New(desc)
return true
}
return false
}
func exit(err *error) {
if *err != nil {
log.Printf("失败: %s", (*err).Error())
os.Exit(1)
} else {
log.Println("成功")
}
}
func setup() (err error) {
log.SetPrefix("[deployer]: ")
log.SetFlags(0)
log.SetOutput(os.Stdout)
var (
optRegistry string
optCluster string
optEnv string
optBaseImageName string
optCPU string
optMEM string
optDeployment string
)
// flags
flag.StringVar(&optRegistry, "registry", "", "镜像仓库, 指定镜像要推往的仓库地址")
flag.StringVar(&optCluster, "cluster", "", "集群, 决定使用哪个集群配置文件, 使用 $HOME/.deployer/preset-[CLUSTER].yml")
flag.StringVar(&opts.Namespace, "namespace", "", "命名空间, 工作负载在集群中的命名空间")
flag.StringVar(&optDeployment, "deployment", "", "工作负载, 要求和 Kubernetes 上的工作负载名称完全一致（已废弃，使用 -workload）")
flag.StringVar(&opts.Workload, "workload", "", "工作负载名")
flag.StringVar(&opts.WorkloadType, "workload-type", "deployment", "工作负载类型，默认为 deployment")
flag.StringVar(&optEnv, "env", "", "环境名, 决定 deployer.yml 或者 docker-build.XXX.sh, Dockerfile.XXX 文件的选择, 和构建后的镜像标签")
flag.StringVar(&optBaseImageName, "image", "", "镜像基础名称, 默认为 '[命名空间]-[工作负载]'")
flag.StringVar(&opts.Container, "container", "", "容器名称, 默认和 deployment 相同（基于 rancher 习惯）")
flag.BoolVar(&opts.IsInit, "init", false, "容器为 init 类型的容器")
flag.BoolVar(&optKeepGenerated, "keep-generated", false, "保存生成的中间文件, 用于调试")
flag.BoolVar(&opts.KeepImage, "keep-image", false, "在本地 Docker 保留镜像, 便于重复构建, 或者调试")
flag.StringVar(&opts.LimitsCPU, "limits-cpu", "", "CPU 资源限制, 单位必须为 'm', 千分之一核心（废弃, 使用 --cpu 参数）")
flag.StringVar(&opts.LimitsMEM, "limits-mem", "", "MEM 资源限制, 单位必须为 'Mi', 兆字节（废弃, 使用 --mem 参数）")
flag.StringVar(&opts.RequestsCPU, "requests-cpu", "", "CPU 资源请求, 单位必须为 'm', 千分之一核心（废弃, 使用 --cpu 参数）")
flag.StringVar(&opts.RequestsMEM, "requests-mem", "", "MEM 资源请求, 单位必须为 'Mi', 兆字节（废弃, 使用 --mem 参数）")
flag.StringVar(&optCPU, "cpu", "", "CPU 资源配置, 格式 '[申请]:[限额]', 如 50:250, 单位 'm' 千分之一核心")
flag.StringVar(&optMEM, "mem", "", "内存资源配置, 格式 '[申请]:[限额]', 如 64:256, 单位 'Mi' 兆字节")
flag.BoolVar(&optOnlyBuild, "only-build", false, "只执行 build 步骤, 不进行 package, push, deploy 步骤")
flag.BoolVar(&optSkipDeploy, "skip-deploy", false, "只执行 build, package, push 步骤, 不进行 deploy 步骤")
flag.BoolVar(&optOnlyDeploy, "only-deploy", false, "只执行 deploy 步骤, 不进行 build, package, push 步骤")
flag.Parse()
// fix deployment
optDeployment = strings.TrimSpace(optDeployment)
if len(optDeployment) > 0 {
opts.Workload = optDeployment
opts.WorkloadType = "deployment"
}
// extract JOB_NAME
jobNameSplits := strings.Split(os.Getenv("JOB_NAME"), ".")
if len(jobNameSplits) == 2 {
fill(jobNameSplits[0], &opts.Workload)
fill(jobNameSplits[1], &optEnv)
log.Println("从 Jenkins $JOB_NAME 获取到 工作负载 " + opts.Workload + ", 环境 " + optEnv)
} else if len(jobNameSplits) == 4 {
fill(jobNameSplits[0], &optCluster)
fill(jobNameSplits[1], &opts.Namespace)
fill(jobNameSplits[2], &opts.Workload)
fill(jobNameSplits[3], &optEnv)
log.Println("从 Jenkins $JOB_NAME 获取到 集群 " + optCluster + ", 命名空间 " + opts.Namespace + ", 工作负载 " + opts.Workload + ", 环境 " + optEnv)
}
// check target options
sanitize(&optCluster, &opts.Namespace, &opts.Workload, &optEnv)
if missing(&optCluster, &err, "错误: 集群未指定, 使用 --cluster 指定集群") {
return
}
if missing(&opts.Namespace, &err, "错误: 命名空间未指定, 使用 --namespace 指定命名空间") {
return
}
if missing(&opts.Workload, &err, "错误: 工作负载未指定, 使用 --workload, 或者 $JOB_NAME 指定工作负载") {
return
}
if missing(&optEnv, &err, "错误: 环境未指定, 使用 --env 或者 $JOB_NAME 指定环境") {
return
}
log.Printf("部署目标: %s -> %s -> %s (ENV: %s)", optCluster, opts.Namespace, opts.Workload, optEnv)
log.Println("------------------------")
// container
fill(opts.Workload, &opts.Container)
// base image name
fill(opts.Namespace+"-"+opts.Workload, &optBaseImageName)
// preset
var preset Preset
if preset, err = LoadPreset(optCluster); err != nil {
return
}
opts.ExtraAnnotations = preset.ExtraAnnotations
opts.ImagePullSecrets = preset.ImagePullSecrets
opts.ScriptKubeconfig = preset.GenerateKubeconfig()
opts.ScriptDockerconfig = preset.GenerateDockerconfig()
fill(preset.Registry, &optRegistry)
// check registry configuration
if missing(&optRegistry, &err, "错误: 镜像仓库未指定, 使用 --registry 指定镜像仓库") {
return
}
// generate image name
buildNumber := os.Getenv("BUILD_NUMBER")
if buildNumber == "" {
opts.ImageName = path.Join(optRegistry, optBaseImageName+":"+optEnv)
} else {
opts.ImageName = path.Join(optRegistry, optBaseImageName+":"+optEnv+"-build-"+buildNumber)
opts.ImageNameAlt = path.Join(optRegistry, optBaseImageName+":"+optEnv)
}
log.Printf("镜像完整名称: %s", opts.ImageName)
if opts.ImageNameAlt != "" {
log.Printf("镜像别名: %s", opts.ImageNameAlt)
}
// load manifest
var mf Manifest
if mf, err = LoadManifest(optEnv); err != nil {
return
}
opts.ScriptBuild = mf.GenerateBuild()
opts.ScriptPackage = mf.GenerateDockerfile()
// manifest resources
if len(optCPU) > 0 {
mf.CPU = optCPU
}
if len(optMEM) > 0 {
mf.MEM = optMEM
}
fill(mf.RequestsCPU(), &opts.RequestsCPU)
fill(mf.LimitsCPU(), &opts.LimitsCPU)
fill(mf.RequestsMEM(), &opts.RequestsMEM)
fill(mf.LimitsMEM(), &opts.LimitsMEM)
// preset resources
fill(preset.RequestsCPU, &opts.RequestsCPU)
fill(preset.LimitsCPU, &opts.LimitsCPU)
fill(preset.RequestsMEM, &opts.RequestsMEM)
fill(preset.LimitsMEM, &opts.LimitsMEM)
return
}
func main() {
var err error
defer exit(&err)
// setup
if err = setup(); err != nil {
return
}
if !optKeepGenerated {
defer tempfile.DeleteAll()
}
if !optOnlyDeploy {
if err = runBuildStage(opts); err != nil {
return
}
if optOnlyBuild {
return
}
if err = runPackageStage(opts); err != nil {
return
}
if err = runPushStage(opts); err != nil {
return
}
if optSkipDeploy {
return
}
}
if err = runDeployStage(opts); err != nil {
return
}
}
|
package factorial
import "fmt"
func Factorial(n uint) uint {
if n == 1 || n == 0 {
return 1
}
return n * Factorial(n-1)
}
|
package main
import (
"bytes"
"context"
"fmt"
"log"
"os"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/s3"
)
// CustomEvent for lambda
type CustomEvent struct {
ID string
Name string
}
var (
awsRegion string
awsEndpoint string
bucketName string
s3svc *s3.Client
)
func init() {
awsRegion = os.Getenv("AWS_REGION")
awsEndpoint = os.Getenv("AWS_ENDPOINT")
bucketName = os.Getenv("S3_BUCKET")
customResolver := aws.EndpointResolverFunc(func(service, region string) (aws.Endpoint, error) {
if awsEndpoint != "" {
return aws.Endpoint{
PartitionID: "aws",
URL: awsEndpoint,
SigningRegion: awsRegion,
}, nil
}
// returning EndpointNotFoundError will allow the service to fallback to it's default resolution
return aws.Endpoint{}, &aws.EndpointNotFoundError{}
})
awsCfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithRegion(awsRegion),
config.WithEndpointResolver(customResolver),
)
if err != nil {
log.Fatalf("Cannot load the AWS configs: %s", err)
}
s3svc = s3.NewFromConfig(awsCfg, func(o *s3.Options) {
o.UsePathStyle = true
})
}
func handler(ctx context.Context, event CustomEvent) error {
s3Key := fmt.Sprintf("%s.txt", event.ID)
body := []byte(fmt.Sprintf("Hello, %s", event.Name))
resp, err := s3svc.PutObject(context.TODO(), &s3.PutObjectInput{
Bucket: aws.String(bucketName),
Key: aws.String(s3Key),
Body: bytes.NewReader(body),
ContentLength: int64(len(body)),
ContentType: aws.String("application/text"),
ContentDisposition: aws.String("attachment"),
})
log.Printf("S3 PutObject response: %+v", resp)
if err != nil {
return err
}
return nil
}
func main() {
lambda.Start(handler)
}
|
package center
import (
"time"
"github.com/golang/glog"
"github.com/gorilla/websocket"
)
// implements Ws
type connection struct {
*websocket.Conn
send chan []byte
central Central
quit chan struct{}
}
func NewConn(central Central, ws *websocket.Conn, quit chan struct{}) Ws {
return &connection{
Conn: ws,
send: make(chan []byte, 64),
central: central,
quit: quit,
}
}
func (conn connection) Send(msg []byte) {
conn.send <- msg
}
func (conn connection) WriteClose() {
ticker := time.NewTicker(conn.central.Conf().GetPingSecond())
defer func() {
glog.Infoln("conn closing")
if err := recover(); err != nil {
glog.Errorln(err)
}
ticker.Stop()
conn.Close()
}()
for {
select {
case msg, ok := <-conn.send:
if !ok {
conn.WriteMessage(websocket.CloseMessage, []byte{})
glog.Infoln("conn send closing")
return
}
if err := conn.WriteMessage(websocket.TextMessage, msg); err != nil {
glog.Infoln("conn send error:", string(msg), err)
return
}
case <-ticker.C:
if err := conn.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
glog.Infoln("conn send ping error", err)
return
}
case <-conn.quit:
return
}
}
return
}
|
package pie_test
import (
"github.com/elliotchance/pie/v2"
"github.com/stretchr/testify/assert"
"math/rand"
"testing"
)
var randomTests = []struct {
ss []float64
expected float64
source rand.Source
}{
{
nil,
0.0,
nil,
},
{
nil,
0.0,
rand.NewSource(0),
},
{
[]float64{},
0.0,
rand.NewSource(0),
},
{
[]float64{12.3, 2.34, 4.56},
12.3,
rand.NewSource(0),
},
{
[]float64{12.3, 2.34, 4.56},
4.56,
rand.NewSource(1),
},
{
[]float64{12.3},
12.3,
rand.NewSource(0),
},
}
func TestRandom(t *testing.T) {
for _, test := range randomTests {
t.Run("", func(t *testing.T) {
assert.Equal(t, test.expected, pie.Random(test.ss, test.source))
})
}
}
|
package parser
import (
"cpl/variable"
"strconv"
"strings"
"errors"
"fmt"
"os"
"bufio"
)
type OpType int
const (
NULL OpType = iota + 1
ADD
SUB
MUL
DIV
MOD
EXP
FAC
AND
OR
NOT
EQU
GT
LT
GTE
LTE
NEQ
EQU2
GT2
LT2
GTE4
LTE4
)
func AlgebraicParser(expression string, variableMap []map[string]variable.Variable ) (variable.Variable, error) {
inQuotes := false
parenthCount := 0
addSubIndex := -1
mulDivIndex := -1
expIndex := -1
facIndex := -1
andIndex := -1
orIndex := -1
notIndex := -1
equIndex := -1
optype := NULL
//currIndex := -1
//inquotes := false
expression_arr := []rune(expression)
if len(expression_arr) == 0 {
fmt.Println("Expression is Null")
returnVar := variable.Variable{}
return returnVar, errors.New("Expression is Null")
}
for i := 0; i < len(expression_arr); i++ {
if expression_arr[i] == '(' || expression_arr[i] == '（' {
parenthCount += 1
continue
} else if expression_arr[i] == ')' || expression_arr[i] == '）' {
parenthCount -= 1
continue
} else if expression_arr[i] == '"' || expression_arr[i] == '\'' || expression_arr[i] == '”' || expression_arr[i] == '“' || expression_arr[i] == '‘' || expression_arr[i] == '’' {
//fmt.Println("HERE in this one")
inQuotes = !inQuotes
} else if inQuotes && expression_arr[i] == '#' {
i++
continue
} else if parenthCount == 0 && !inQuotes {
switch expression_arr[i] {
case '+':
addSubIndex = i
optype = ADD
break
case '-':
addSubIndex = i
optype = SUB
break
case '*':
mulDivIndex = i
optype = MUL
break
case '/':
mulDivIndex = i
optype = DIV
break
case '%':
mulDivIndex = i
optype = MOD
break
case '^':
expIndex = i
optype = EXP
break
case '!':
facIndex = i
optype = FAC
break
case '与':
andIndex = i
optype = AND
break
case '或':
orIndex = i
optype = OR
break
case '非':
notIndex = i
optype = NOT
break
case '=':
equIndex = i
optype = EQU
break
case '>':
equIndex = i
optype = GT
break
case '<':
equIndex = i
optype = LT
break
}
if i < len(expression_arr)-1 {
if expression_arr[i] == '等' && expression_arr[i+1] == '于' {
equIndex = i
optype = EQU2
} else if expression_arr[i] == '大' && expression_arr[i+1] == '于' {
equIndex = i
optype = GT2
} else if expression_arr[i] == '小' && expression_arr[i+1] == '于' {
equIndex = i
optype = LT2
} else if i < len(expression_arr)-2 {
if expression_arr[i] == '不' && expression_arr[i+1] == '等' && expression_arr[i+2] == '于' {
equIndex = i
optype = NEQ
} else if i < len(expression_arr)-3 {
if expression_arr[i] == '大' && expression_arr[i+1] == '于' && expression_arr[i+2] == '等' && expression_arr[i+3] == '于' {
equIndex = i
optype = GTE4
} else if expression_arr[i] == '小' && expression_arr[i+1] == '于' && expression_arr[i+2] == '等' && expression_arr[i+3] == '于' {
equIndex = i
optype = LTE4
}
}
}
}
}
}
//fmt.Println(expression)
if orIndex != -1 {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[equIndex+1:]),variableMap)
if err != nil {
return part2, err
}
return part1.Or(part2)
}
if andIndex != -1 {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[equIndex+1:]),variableMap)
if err != nil {
return part2, err
}
return part1.And(part2)
}
if notIndex != -1 {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
return part1.Not()
}
if equIndex != -1 {
if optype == EQU {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[equIndex+1:]),variableMap)
if err != nil {
return part2, err
}
return part1.Eq(part2)
}
if optype == EQU2 {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[equIndex+2:]),variableMap)
if err != nil {
return part2, err
}
return part1.Eq(part2)
}
if optype == NEQ {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[equIndex+3:]),variableMap)
if err != nil {
return part2, err
}
return part1.Neq(part2)
}
if optype == GT {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[equIndex+1:]),variableMap)
if err != nil {
return part2, err
}
return part1.Gt(part2)
}
if optype == LT {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[equIndex+1:]),variableMap)
if err != nil {
return part2, err
}
return part1.Lt(part2)
}
if optype == GT2 {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[equIndex+2:]),variableMap)
if err != nil {
return part2, err
}
return part1.Gt(part2)
}
if optype == LT2 {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[equIndex+2:]),variableMap)
if err != nil {
return part2, err
}
return part1.Lt(part2)
}
if optype == GTE4 {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[equIndex+4:]),variableMap)
if err != nil {
return part2, err
}
return part1.Gte(part2)
}
if optype == LTE4 {
part1, err := AlgebraicParser(string(expression_arr[:equIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[equIndex+4:]),variableMap)
if err != nil {
return part2, err
}
return part1.Lte(part2)
}
}
if addSubIndex != -1 {
if optype == ADD {
part1, err := AlgebraicParser(string(expression_arr[:addSubIndex]), variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[addSubIndex+1:]), variableMap)
if err != nil {
return part2, err
}
return part1.Add(part2)
} else if optype == SUB {
part1, err := AlgebraicParser(string(expression_arr[:addSubIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[addSubIndex+1:]),variableMap)
if err != nil {
return part2, err
}
return part1.Sub(part2)
}
} else if mulDivIndex != -1 {
if optype == MUL {
part1, err := AlgebraicParser(string(expression_arr[:mulDivIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[mulDivIndex+1:]),variableMap)
if err != nil {
return part2, err
}
return part1.Mul(part2)
} else if optype == DIV {
part1, err := AlgebraicParser(string(expression_arr[:mulDivIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[mulDivIndex+1:]),variableMap)
if err != nil {
return part2, err
}
return part1.Div(part2)
} else if optype == MOD {
part1, err := AlgebraicParser(string(expression_arr[:mulDivIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[mulDivIndex+1:]),variableMap)
if err != nil {
return part2, err
}
return part1.Mod(part2)
}
} else if expIndex != -1 {
part1, err := AlgebraicParser(string(expression_arr[:expIndex]),variableMap)
if err != nil {
return part1, err
}
part2, err := AlgebraicParser(string(expression_arr[expIndex+1:]),variableMap)
if err != nil {
return part2, err
}
return part1.Exp(part2)
} else if facIndex != -1 {
part1, err := AlgebraicParser(string(expression_arr[:expIndex]),variableMap)
if err != nil {
return part1, err
}
return part1.Fac()
} else if expression_arr[0] == '(' && expression_arr[len(expression_arr)-1] == ')' {
return AlgebraicParser(string(expression_arr[1:len(expression_arr)-1]),variableMap)
} else if (expression_arr[0] == '"' || expression_arr[0] == '\'' || expression_arr[0] == '”' || expression_arr[0] == '“' || expression_arr[0] == '‘' || expression_arr[0] == '’') && (expression_arr[len(expression_arr)-1] == '"' || expression_arr[len(expression_arr)-1] == '\'' || expression_arr[len(expression_arr)-1] == '”' || expression_arr[len(expression_arr)-1] == '“' || expression_arr[len(expression_arr)-1] == '‘' || expression_arr[len(expression_arr)-1] == '’') {
return StringParser(string(expression_arr[1:len(expression_arr)-1]))
} else {
return EvaluateAtom(string(expression_arr),variableMap)
}
return variable.Variable{}, nil
}
func EvaluateAtom(expression string, variableMap []map[string]variable.Variable) (variable.Variable, error) {
returnVar := variable.Variable{}
////////////////////
// ARRAY []
////////////////////
if ( strings.HasSuffix(expression,"]") || strings.HasSuffix(expression,"】") ) && ( strings.HasPrefix(expression,"[") || strings.HasPrefix(expression,"【") ) {
returnVar.TypeCode = variable.ARRAY
expr_arr := []rune(expression)
expr_arr = expr_arr[1:len(expr_arr)-1]
array_elements_arr := strings.FieldsFunc(string(expr_arr),SplitByCommas)
returnVar.ArrayVal = nil
for _, el := range array_elements_arr {
tempVar, err := AlgebraicParser(el, variableMap)
if err != nil {
//fmt.Println("Error Occurred")
return returnVar, err
}
//fmt.Println("Added Element")
returnVar.ArrayVal = append(returnVar.ArrayVal,tempVar)
}
//fmt.Println(len(returnVar.ArrayVal))
return returnVar, nil
}
////////////////////
// ARRAYS and STRINGS
////////////////////
if strings.HasSuffix(expression,"]") || strings.HasSuffix(expression,"】") {
expr_arr := []rune(expression)
var name []rune
var i int
for i = 0; i < len(expr_arr); i++ {
if expr_arr[i] == '[' || expr_arr[i] == '【' {
break
} else {
name = append(name, expr_arr[i])
}
}
if i >= len(expr_arr) {
return returnVar, errors.New("No opening [")
}
expr_arr = expr_arr[i+1:len(expr_arr)-1]
arg_arr := strings.Split(string(expr_arr),"][") //TODO Also split by other type of brackets
for _, vmap := range variableMap {
if val, exists := vmap[string(name)]; exists {
if val.TypeCode != variable.STRING && val.TypeCode != variable.ARRAY {
return returnVar, errors.New("Variable Cannot Be Indexed")
}
if val.TypeCode == variable.ARRAY {
for _, arg := range arg_arr {
tempVar, err := AlgebraicParser(arg,variableMap)
if err != nil {
return returnVar, err
}
//fmt.Println("Index Parsed")
//fmt.Println(tempVar)
if tempVar.TypeCode == variable.FLOAT {
//TODO Round to nearest Int
}
if tempVar.TypeCode != variable.INT {
return returnVar, errors.New("Index must evaluate to int or float")
}
//fmt.Println("Type Code is integer")
//fmt.Println(tempVar.IntVal)
returnVar = val.ArrayVal[tempVar.IntVal]
return returnVar, nil
}
}
if val.TypeCode ==variable.STRING {
if len(arg_arr) > 1 {
return returnVar, errors.New("String only has one dimension")
}
tempVar, err := AlgebraicParser(arg_arr[0],variableMap)
if err != nil {
return returnVar, err
}
if tempVar.TypeCode == variable.FLOAT {
//TODO Round to nearest Int
}
if tempVar.TypeCode != variable.INT {
return returnVar, errors.New("Index must evaluate to int or float")
}
tempSlice := []rune(val.StringVal)
returnVar.StringVal = string(tempSlice[tempVar.IntVal])
returnVar.TypeCode = variable.STRING
return returnVar, nil
}
}
}
}
if strings.HasSuffix(expression,")") || strings.HasSuffix(expression,"）") {
expr_arr := []rune(expression)
var name []rune
var i int
for i = 0; i < len(expr_arr); i++ {
if expr_arr[i] == '(' || expr_arr[i] == '（' {
break
} else {
name = append(name,expr_arr[i])
}
}
if i >= len(expr_arr) {
return returnVar, errors.New("Improperly Formed Function Call")
}
expr_arr = expr_arr[i+1:len(expr_arr)-1]
arg_arr := strings.FieldsFunc(string(expr_arr),SplitByCommas)
////////////////////////
// INPUT
////////////////////////
if string(name) == "输入" {
if len(arg_arr) != 1 {
return returnVar, errors.New("Incorrect Number of Args")
}
tempVar, err := AlgebraicParser(arg_arr[0],variableMap)
if err != nil {
return returnVar, err
}
inputBuffer := bufio.NewReader(os.Stdin)
output_str, err := tempVar.ToString()
if err != nil {
return returnVar, err
}
fmt.Printf(output_str)
input_text, err := inputBuffer.ReadString('\n')
if err != nil {
return returnVar, err
}
input_text = strings.Replace(input_text,"\r\n","",-1)
input_text = strings.Replace(input_text,"\n","",-1)
float_val, err := strconv.ParseFloat(input_text,64)
if err == nil {
returnVar.TypeCode = variable.FLOAT
returnVar.FloatVal = float_val
return returnVar, nil
}
int_val, err := strconv.ParseInt(input_text,10,64)
if err == nil {
returnVar.TypeCode = variable.INT
returnVar.IntVal = int_val
return returnVar, nil
}
//fmt.Printf("String Type Generated by Input") //DEBUG
//fmt.Printf(error.Error(err))
returnVar.TypeCode = variable.STRING
returnVar.StringVal = input_text
return returnVar, nil
}
for _, vmap := range variableMap {
//fmt.Println("Searching for" + string(name))
if val, exists := vmap[string(name)]; exists {
//fmt.Println("Match Found")
if val.TypeCode == variable.FUNC {
workspace := []map[string]variable.Variable{}
workspace = append(workspace, variableMap[0])
workspace = append(workspace, map[string]variable.Variable{})
if len(arg_arr) != len(val.FuncArgs) {
return returnVar, errors.New("Incorrect Number of Args")
}
for j := 0; j < len(val.FuncArgs); j++ {
tempVar, err := AlgebraicParser(arg_arr[j],variableMap)
workspace[0][val.FuncArgs[j]] = tempVar
if err != nil {
return returnVar, errors.New("Errors evaluating function arg")
}
}
//fmt.Println("Parsing Script")
workspace, _, err := ParseScript(val.FuncVal,val.FuncLines,workspace)
if err != nil {
return returnVar, err
}
return workspace[0]["+返回价值"], nil
}
}
}
return returnVar, errors.New("Function Name Not Found")
}
value, err := strconv.ParseInt(expression,10,64)
if err != nil {
value, err := strconv.ParseInt(expression,10,64)
if err != nil {
if ( strings.HasPrefix(expression,"\"") || strings.HasPrefix(expression,"“") || strings.HasPrefix(expression,"”") ) && ( strings.HasSuffix(expression,"\"") || strings.HasSuffix(expression,"“") || strings.HasSuffix(expression,"”") ) {
returnVar.TypeCode = variable.STRING
returnVar.StringVal = expression[1:len(expression)-1]
return returnVar, nil
} else {
for _, vmap := range variableMap {
if val, exists := vmap[expression]; exists {
if val.TypeCode == variable.FUNC {
workspace := []map[string]variable.Variable{}
workspace = append(workspace, map[string]variable.Variable{})
workspace, _, err := ParseScript(val.FuncVal,val.FuncLines,workspace)
if err != nil {
return returnVar, err
}
return workspace[0]["+返回价值"], nil
} else {
return val, nil
}
}
}
}
}
returnVar.TypeCode = variable.FLOAT
returnVar.IntVal = value
return returnVar, nil
}
returnVar.TypeCode = variable.INT
returnVar.IntVal = value
return returnVar, nil
}
func SplitByCommas( r rune ) bool {
return r == ',' || r == '、'
}
|
package main
import (
"fmt"
)
// 定义一个用户接口
type IUser interface {
// 定义say方法
say()
}
// 定义一个人接口
type IPersoner interface {
// 通过匿名字段方式继承IUser
IUser
// 定义run方法
run()
}
// 定义学生结构体
type Student struct {
id int
name string
}
// 给学生结构体绑定say方法
func (s *Student) say() {
fmt.Printf("Student %s say...\n", s.name)
}
// 给学生结构体绑定run方法
func (s *Student) run() {
fmt.Printf("Student %s run...\n", s.name)
}
func main() {
// 定义IPersoner类型变量
var personer IPersoner
// 由于Student是绑定了IPersoner的方法（包括继承的方法）
personer = &Student{id: 123, name: "neil"}
personer.say()
personer.run()
// 由于IPersoner接口继承IUser接口，则IPersoner类型可以转换成IUser类型
var user IUser
user = personer
user.say()
// 结果为：
// Student neil say...
// Student neil run...
// Student neil say...
}
|
package parser
type Names struct {
nameToID map[string]int
names []string
}
func (n *Names) IDFromName(name string) int {
if n.nameToID == nil {
n.nameToID = make(map[string]int, 100)
}
id, ok := n.nameToID[name]
if !ok {
n.names = append(n.names, name)
id = len(n.names) - 1
n.nameToID[name] = id
}
return id + 1
}
func (n *Names) NameFromID(id int) string {
return n.names[id-1]
}
|
/*****************************************************************
* Copyright©,2020-2022, email: 279197148@qq.com
* Version: 1.0.0
* @Author: yangtxiang
* @Date: 2020-08-16 10:31
* Description:
*****************************************************************/
package pdl
import (
"github.com/apache/thrift/lib/go/thrift"
"github.com/go-xe2/x/xf/ef/xqi"
)
type TStructFieldInfo struct {
Id int16
FdType thrift.TType
Setter func(obj DynamicStruct, val interface{}) bool
}
type DynamicStruct interface {
NewInstance() DynamicStruct
AllFields() map[string]*TStructFieldInfo
FieldNameMaps() map[string]string
SetFieldValue(fdName string, val interface{}) bool
AssignFromMap(mp map[string]interface{}) bool
SliceFromMaps(mps []map[string]interface{}) []thrift.TStruct
AssignFromDataSet(ds xqi.Dataset) bool
SliceFromDataSet(ds xqi.Dataset) []thrift.TStruct
}
func NewStructFieldInfo(id int16, fdType thrift.TType, setter func(obj DynamicStruct, val interface{}) bool) *TStructFieldInfo {
return &TStructFieldInfo{
Id: id,
FdType: fdType,
Setter: setter,
}
}
|
package bit_map
import (
"fmt"
"math"
"strings"
)
const BitSize = 8
// 误判率大约在 (万分之5)~(万分之7)
type BitMap struct {
bitArray []byte
Size uint32
}
func (bm *BitMap) Init() {
if bm.Size > 1<<32-1 {
panic("bit map Size over flow")
}
var r uint32
if bm.Size <= 1 {
r = 1
} else {
r = uint32(math.Ceil(float64(bm.Size) / BitSize))
}
bm.bitArray = make([]byte, r)
}
func (bm *BitMap) calIdx(i uint32) (idx uint32, pos uint32) {
idx = i >> 3
pos = i & (BitSize - 1)
return
}
func (bm *BitMap) Set(i uint32) error {
if i > bm.Size {
return fmt.Errorf("bit map Size over flow, max Size=[%d], error position=[%d]", bm.Size, i)
}
idx, pos := bm.calIdx(i)
bm.bitArray[idx] |= 1 << (pos - 1)
return nil
}
func (bm *BitMap) Exists(i uint32) bool {
if i > bm.Size {
return false
}
idx, pos := bm.calIdx(i)
return bm.bitArray[idx]&(1<<(pos-1)) == 1<<(pos-1)
}
func (bm *BitMap) String() string {
strs := make([]string, 0, len(bm.bitArray))
for _, b := range bm.bitArray {
strs = append(strs, byte2String(b))
}
return strings.Join(strs, "-")
}
func byte2String(b byte) string {
var magicBit uint32 = 1
str := ""
for i := 0; i < BitSize; i++ {
u := magicBit << uint32(i)
if uint32(b)&u == u {
str += "1"
} else {
str += "0"
}
}
return str
}
|
package group
import (
"github.com/gookit/gcli/v3"
"github.com/ovrclk/akash/x/deployment/types"
"github.com/ovrclk/akcmd/client"
"github.com/ovrclk/akcmd/flags"
)
func TxCmd() *gcli.Command {
cmd := &gcli.Command{
Name: "group",
Desc: "Modify a Deployment's specific Group",
Func: func(cmd *gcli.Command, args []string) error {
cmd.ShowHelp()
return nil
},
Subs: []*gcli.Command{CloseCMD(), pauseCMD(), startCMD()},
}
return cmd
}
func CloseCMD() *gcli.Command {
cmd := &gcli.Command{
Name: "close",
Desc: "close a Deployment's specific Group",
Config: func(cmd *gcli.Command) {
flags.AddTxFlagsToCmd(cmd)
flags.AddGroupIDFlags(cmd)
flags.MarkReqGroupIDFlags(cmd)
},
Func: func(cmd *gcli.Command, args []string) error {
clientCtx, err := client.GetClientTxContext()
if err != nil {
return err
}
id, err := flags.GroupIDFromFlags()
if err != nil {
return err
}
msg := &types.MsgCloseGroup{
ID: id,
}
if err := msg.ValidateBasic(); err != nil {
return err
}
return client.BroadcastTX(clientCtx, msg)
},
}
return cmd
}
func pauseCMD() *gcli.Command {
cmd := &gcli.Command{
Name: "pause",
Desc: "pause a Deployment's specific Group",
Config: func(cmd *gcli.Command) {
flags.AddTxFlagsToCmd(cmd)
flags.AddGroupIDFlags(cmd)
flags.MarkReqGroupIDFlags(cmd)
},
Func: func(cmd *gcli.Command, args []string) error {
clientCtx, err := client.GetClientTxContext()
if err != nil {
return err
}
id, err := flags.GroupIDFromFlags()
if err != nil {
return err
}
msg := &types.MsgPauseGroup{
ID: id,
}
if err := msg.ValidateBasic(); err != nil {
return err
}
return client.BroadcastTX(clientCtx, msg)
},
}
return cmd
}
func startCMD() *gcli.Command {
cmd := &gcli.Command{
Name: "start",
Desc: "start a Deployment's specific Group",
Config: func(cmd *gcli.Command) {
flags.AddTxFlagsToCmd(cmd)
flags.AddGroupIDFlags(cmd)
flags.MarkReqGroupIDFlags(cmd)
},
Func: func(cmd *gcli.Command, args []string) error {
clientCtx, err := client.GetClientTxContext()
if err != nil {
return err
}
id, err := flags.GroupIDFromFlags()
if err != nil {
return err
}
msg := &types.MsgStartGroup{
ID: id,
}
if err := msg.ValidateBasic(); err != nil {
return err
}
return client.BroadcastTX(clientCtx, msg)
},
}
return cmd
}
|
package query
import (
"github.com/garyburd/redigo/redis"
"github.com/mezis/klask/index"
"github.com/mezis/klask/util/tempkey"
)
type Context interface {
Conn() redis.Conn
Keys() tempkey.Keys
Idx() index.Index
}
type context_t struct {
idx index.Index
keys tempkey.Keys
}
func newContext(idx index.Index) *context_t {
rv := new(context_t)
rv.idx = idx
rv.keys = tempkey.New(idx.Conn)
return rv
}
func (self *context_t) Conn() redis.Conn {
return self.idx.Conn()
}
func (self *context_t) Idx() index.Index {
return self.idx
}
func (self *context_t) Keys() tempkey.Keys {
return self.keys
}
|
package main
import (
"fmt"
"log"
"net/http"
"net/http/httptest"
"net/http/httputil"
)
func main() {
const body = "Go is a general-purpose language designed with systems programming in mind."
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Date", "Wed, 19 Jul 1972 19:00:00 GMT")
fmt.Fprintln(w, body)
}))
defer ts.Close()
resp, err := http.Get(ts.URL)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
dump, err := httputil.DumpResponse(resp, true)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%q\n", dump)
}
|
package models
import (
"database/sql"
"encoding/json"
)
type NullString struct {
sql.NullString
}
func (r NullString) MarshalJSON() ([]byte, error) {
if r.Valid {
return json.Marshal(r.String)
}
return json.Marshal(nil)
}
|
package twosum
func twoSum(nums []int, target int) []int {
mapDiff := make(map[int]int)
for i, value := range nums {
if j, ok := mapDiff[value]; ok {
return []int{j, i}
}
diff := target - value
mapDiff[diff] = i
}
return nil
}
|
package isogram
import (
"strings"
)
// IsIsogram takes a string and returns true if there are no duplicated
// characters excluding "-" and " ".
func IsIsogram(word string) bool {
word = strings.ToLower(word)
seen := 0
for _, c := range word {
switch string(c) {
case "-":
continue
case " ":
continue
}
if strings.Count(word, string(c)) > 1 {
seen++
}
}
if seen > 0 {
return false
}
return true
}
|
package main
import (
"fmt"
)
// 145. 二叉树的后序遍历
// https://leetcode-cn.com/problems/binary-tree-postorder-traversal/
func main() {
tree := &TreeNode{
Val: 1,
Right: &TreeNode{
Val: 2,
Left: &TreeNode{
Val: 3,
},
},
}
fmt.Println(postorderTraversal(tree))
fmt.Println(postorderTraversal2(tree))
fmt.Println(postorderTraversal3(tree))
}
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
// 法一：递归
func postorderTraversal(root *TreeNode) []int {
if root == nil {
return nil
}
result := postorderTraversal(root.Left)
result = append(result, postorderTraversal(root.Right)...)
result = append(result, root.Val)
return result
}
// 法二：迭代
// 由于后序遍历的顺序是：左-右-根，所以将根节点压栈两次
// 第一个根节点用于将右、左节点压栈，第二个用于输出根节点的值
func postorderTraversal2(root *TreeNode) (result []int) {
if root == nil {
return nil
}
stack := []*TreeNode{root, root}
for len(stack) > 0 {
cur := stack[len(stack)-1]
stack = stack[:len(stack)-1]
if len(stack) > 0 && cur == stack[len(stack)-1] {
if cur.Right != nil {
stack = append(stack, cur.Right)
stack = append(stack, cur.Right)
}
if cur.Left != nil {
stack = append(stack, cur.Left)
stack = append(stack, cur.Left)
}
} else {
result = append(result, cur.Val)
}
}
return
}
// 法三：颜色遍历
type colorNode struct {
node *TreeNode
color int
}
func postorderTraversal3(root *TreeNode) (result []int) {
if root == nil {
return nil
}
white, gray := 0, 1
stack := []colorNode{colorNode{root, white}}
for len(stack) > 0 {
cur := stack[len(stack)-1]
stack = stack[:len(stack)-1]
if cur.node != nil {
if cur.color == white {
cur.color = gray
stack = append(stack, cur)
stack = append(stack, colorNode{cur.node.Right, white})
stack = append(stack, colorNode{cur.node.Left, white})
} else {
result = append(result, cur.node.Val)
}
}
}
return
}
|
package main
func sortArray(nums []int) []int {
quickSort(0, len(nums)-1, nums)
return nums
}
func partition(i, j int, nums []int) int {
key := nums[i]
left := i
for i < j {
for i < j && nums[j] > key {
j--
}
for i < j && nums[i] <= key {
i++
}
if i < j {
nums[i], nums[j] = nums[j], nums[i]
}
}
nums[i], nums[left] = nums[left], nums[i]
return i
}
func quickSort(i, j int, nums []int) {
if i >= j {
return
}
index := partition(i, j, nums)
quickSort(i, index-1, nums)
quickSort(index+1, j, nums)
}
|
package main
import "fmt"
func main() {
name := "Eko"
switch name {
case "Eko":
fmt.Println("Hello Eko")
case "Joko":
fmt.Println("Hello Joko")
default:
fmt.Println("Salam kenal")
}
// switch short statement
switch length := len(name); length > 5 {
case true:
fmt.Println("Nama terlalu panjang")
case false:
fmt.Println("Nama sudah benar")
}
// switch without condition
value := 70
switch {
case value >= 80:
fmt.Println("Nilai anda A")
case value >= 60:
fmt.Println("Nilai anda B")
default:
fmt.Println("Nilai anda C")
}
}
|
// Copyright 2023 Google LLC. All Rights Reserved.
//
// 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 osconfig
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io/ioutil"
"strings"
"github.com/GoogleCloudPlatform/declarative-resource-client-library/dcl"
)
func (r *OSPolicyAssignment) validate() error {
if err := dcl.Required(r, "name"); err != nil {
return err
}
if err := dcl.Required(r, "osPolicies"); err != nil {
return err
}
if err := dcl.Required(r, "instanceFilter"); err != nil {
return err
}
if err := dcl.Required(r, "rollout"); err != nil {
return err
}
if err := dcl.RequiredParameter(r.Project, "Project"); err != nil {
return err
}
if err := dcl.RequiredParameter(r.Location, "Location"); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.InstanceFilter) {
if err := r.InstanceFilter.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Rollout) {
if err := r.Rollout.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPolicies) validate() error {
if err := dcl.Required(r, "id"); err != nil {
return err
}
if err := dcl.Required(r, "mode"); err != nil {
return err
}
if err := dcl.Required(r, "resourceGroups"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroups) validate() error {
if err := dcl.Required(r, "resources"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) validate() error {
if err := dcl.Required(r, "osShortName"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResources) validate() error {
if err := dcl.Required(r, "id"); err != nil {
return err
}
if err := dcl.ValidateExactlyOneOfFieldsSet([]string{"Pkg", "Repository", "Exec", "File"}, r.Pkg, r.Repository, r.Exec, r.File); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Pkg) {
if err := r.Pkg.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Repository) {
if err := r.Repository.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Exec) {
if err := r.Exec.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.File) {
if err := r.File.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) validate() error {
if err := dcl.Required(r, "desiredState"); err != nil {
return err
}
if err := dcl.ValidateAtMostOneOfFieldsSet([]string{"Apt", "Deb", "Yum", "Zypper", "Rpm", "Googet", "Msi"}, r.Apt, r.Deb, r.Yum, r.Zypper, r.Rpm, r.Googet, r.Msi); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Apt) {
if err := r.Apt.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Deb) {
if err := r.Deb.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Yum) {
if err := r.Yum.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Zypper) {
if err := r.Zypper.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Rpm) {
if err := r.Rpm.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Googet) {
if err := r.Googet.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Msi) {
if err := r.Msi.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) validate() error {
if err := dcl.Required(r, "name"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) validate() error {
if err := dcl.Required(r, "source"); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Source) {
if err := r.Source.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) validate() error {
if err := dcl.ValidateAtMostOneOfFieldsSet([]string{"Remote", "Gcs", "LocalPath"}, r.Remote, r.Gcs, r.LocalPath); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Remote) {
if err := r.Remote.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Gcs) {
if err := r.Gcs.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) validate() error {
if err := dcl.Required(r, "uri"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) validate() error {
if err := dcl.Required(r, "bucket"); err != nil {
return err
}
if err := dcl.Required(r, "object"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) validate() error {
if err := dcl.Required(r, "name"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) validate() error {
if err := dcl.Required(r, "name"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) validate() error {
if err := dcl.Required(r, "source"); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Source) {
if err := r.Source.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) validate() error {
if err := dcl.ValidateAtMostOneOfFieldsSet([]string{"Remote", "Gcs", "LocalPath"}, r.Remote, r.Gcs, r.LocalPath); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Remote) {
if err := r.Remote.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Gcs) {
if err := r.Gcs.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) validate() error {
if err := dcl.Required(r, "uri"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) validate() error {
if err := dcl.Required(r, "bucket"); err != nil {
return err
}
if err := dcl.Required(r, "object"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) validate() error {
if err := dcl.Required(r, "name"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) validate() error {
if err := dcl.Required(r, "source"); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Source) {
if err := r.Source.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) validate() error {
if err := dcl.ValidateAtMostOneOfFieldsSet([]string{"Remote", "Gcs", "LocalPath"}, r.Remote, r.Gcs, r.LocalPath); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Remote) {
if err := r.Remote.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Gcs) {
if err := r.Gcs.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) validate() error {
if err := dcl.Required(r, "uri"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) validate() error {
if err := dcl.Required(r, "bucket"); err != nil {
return err
}
if err := dcl.Required(r, "object"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) validate() error {
if err := dcl.ValidateAtMostOneOfFieldsSet([]string{"Apt", "Yum", "Zypper", "Goo"}, r.Apt, r.Yum, r.Zypper, r.Goo); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Apt) {
if err := r.Apt.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Yum) {
if err := r.Yum.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Zypper) {
if err := r.Zypper.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Goo) {
if err := r.Goo.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) validate() error {
if err := dcl.Required(r, "archiveType"); err != nil {
return err
}
if err := dcl.Required(r, "uri"); err != nil {
return err
}
if err := dcl.Required(r, "distribution"); err != nil {
return err
}
if err := dcl.Required(r, "components"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) validate() error {
if err := dcl.Required(r, "id"); err != nil {
return err
}
if err := dcl.Required(r, "baseUrl"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) validate() error {
if err := dcl.Required(r, "id"); err != nil {
return err
}
if err := dcl.Required(r, "baseUrl"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) validate() error {
if err := dcl.Required(r, "name"); err != nil {
return err
}
if err := dcl.Required(r, "url"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) validate() error {
if err := dcl.Required(r, "validate"); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Validate) {
if err := r.Validate.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Enforce) {
if err := r.Enforce.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) validate() error {
if err := dcl.Required(r, "interpreter"); err != nil {
return err
}
if err := dcl.ValidateAtMostOneOfFieldsSet([]string{"File", "Script"}, r.File, r.Script); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.File) {
if err := r.File.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) validate() error {
if err := dcl.ValidateAtMostOneOfFieldsSet([]string{"Remote", "Gcs", "LocalPath"}, r.Remote, r.Gcs, r.LocalPath); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Remote) {
if err := r.Remote.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Gcs) {
if err := r.Gcs.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) validate() error {
if err := dcl.Required(r, "uri"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) validate() error {
if err := dcl.Required(r, "bucket"); err != nil {
return err
}
if err := dcl.Required(r, "object"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) validate() error {
if err := dcl.Required(r, "interpreter"); err != nil {
return err
}
if err := dcl.ValidateAtMostOneOfFieldsSet([]string{"File", "Script"}, r.File, r.Script); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.File) {
if err := r.File.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) validate() error {
if err := dcl.ValidateAtMostOneOfFieldsSet([]string{"Remote", "Gcs", "LocalPath"}, r.Remote, r.Gcs, r.LocalPath); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Remote) {
if err := r.Remote.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Gcs) {
if err := r.Gcs.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) validate() error {
if err := dcl.Required(r, "uri"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) validate() error {
if err := dcl.Required(r, "bucket"); err != nil {
return err
}
if err := dcl.Required(r, "object"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) validate() error {
if err := dcl.Required(r, "path"); err != nil {
return err
}
if err := dcl.Required(r, "state"); err != nil {
return err
}
if err := dcl.ValidateAtMostOneOfFieldsSet([]string{"File", "Content"}, r.File, r.Content); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.File) {
if err := r.File.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) validate() error {
if err := dcl.ValidateAtMostOneOfFieldsSet([]string{"Remote", "Gcs", "LocalPath"}, r.Remote, r.Gcs, r.LocalPath); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.Remote) {
if err := r.Remote.validate(); err != nil {
return err
}
}
if !dcl.IsEmptyValueIndirect(r.Gcs) {
if err := r.Gcs.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) validate() error {
if err := dcl.Required(r, "uri"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) validate() error {
if err := dcl.Required(r, "bucket"); err != nil {
return err
}
if err := dcl.Required(r, "object"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentInstanceFilter) validate() error {
return nil
}
func (r *OSPolicyAssignmentInstanceFilterInclusionLabels) validate() error {
return nil
}
func (r *OSPolicyAssignmentInstanceFilterExclusionLabels) validate() error {
return nil
}
func (r *OSPolicyAssignmentInstanceFilterInventories) validate() error {
if err := dcl.Required(r, "osShortName"); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignmentRollout) validate() error {
if err := dcl.Required(r, "disruptionBudget"); err != nil {
return err
}
if err := dcl.Required(r, "minWaitDuration"); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(r.DisruptionBudget) {
if err := r.DisruptionBudget.validate(); err != nil {
return err
}
}
return nil
}
func (r *OSPolicyAssignmentRolloutDisruptionBudget) validate() error {
if err := dcl.ValidateExactlyOneOfFieldsSet([]string{"Fixed", "Percent"}, r.Fixed, r.Percent); err != nil {
return err
}
return nil
}
func (r *OSPolicyAssignment) basePath() string {
params := map[string]interface{}{}
return dcl.Nprintf("https://osconfig.googleapis.com/v1", params)
}
func (r *OSPolicyAssignment) getURL(userBasePath string) (string, error) {
nr := r.urlNormalized()
params := map[string]interface{}{
"project": dcl.ValueOrEmptyString(nr.Project),
"location": dcl.ValueOrEmptyString(nr.Location),
"name": dcl.ValueOrEmptyString(nr.Name),
}
return dcl.URL("projects/{{project}}/locations/{{location}}/osPolicyAssignments/{{name}}", nr.basePath(), userBasePath, params), nil
}
func (r *OSPolicyAssignment) listURL(userBasePath string) (string, error) {
nr := r.urlNormalized()
params := map[string]interface{}{
"project": dcl.ValueOrEmptyString(nr.Project),
"location": dcl.ValueOrEmptyString(nr.Location),
}
return dcl.URL("projects/{{project}}/locations/{{location}}/osPolicyAssignments", nr.basePath(), userBasePath, params), nil
}
func (r *OSPolicyAssignment) createURL(userBasePath string) (string, error) {
nr := r.urlNormalized()
params := map[string]interface{}{
"project": dcl.ValueOrEmptyString(nr.Project),
"location": dcl.ValueOrEmptyString(nr.Location),
"name": dcl.ValueOrEmptyString(nr.Name),
}
return dcl.URL("projects/{{project}}/locations/{{location}}/osPolicyAssignments?osPolicyAssignmentId={{name}}", nr.basePath(), userBasePath, params), nil
}
func (r *OSPolicyAssignment) deleteURL(userBasePath string) (string, error) {
nr := r.urlNormalized()
params := map[string]interface{}{
"project": dcl.ValueOrEmptyString(nr.Project),
"location": dcl.ValueOrEmptyString(nr.Location),
"name": dcl.ValueOrEmptyString(nr.Name),
}
return dcl.URL("projects/{{project}}/locations/{{location}}/osPolicyAssignments/{{name}}", nr.basePath(), userBasePath, params), nil
}
// oSPolicyAssignmentApiOperation represents a mutable operation in the underlying REST
// API such as Create, Update, or Delete.
type oSPolicyAssignmentApiOperation interface {
do(context.Context, *OSPolicyAssignment, *Client) error
}
// newUpdateOSPolicyAssignmentUpdateOSPolicyAssignmentRequest creates a request for an
// OSPolicyAssignment resource's UpdateOSPolicyAssignment update type by filling in the update
// fields based on the intended state of the resource.
func newUpdateOSPolicyAssignmentUpdateOSPolicyAssignmentRequest(ctx context.Context, f *OSPolicyAssignment, c *Client) (map[string]interface{}, error) {
req := map[string]interface{}{}
res := f
_ = res
if v := f.Description; !dcl.IsEmptyValueIndirect(v) {
req["description"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesSlice(c, f.OSPolicies, res); err != nil {
return nil, fmt.Errorf("error expanding OSPolicies into osPolicies: %w", err)
} else if v != nil {
req["osPolicies"] = v
}
if v, err := expandOSPolicyAssignmentInstanceFilter(c, f.InstanceFilter, res); err != nil {
return nil, fmt.Errorf("error expanding InstanceFilter into instanceFilter: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
req["instanceFilter"] = v
}
if v, err := expandOSPolicyAssignmentRollout(c, f.Rollout, res); err != nil {
return nil, fmt.Errorf("error expanding Rollout into rollout: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
req["rollout"] = v
}
if v := f.SkipAwaitRollout; !dcl.IsEmptyValueIndirect(v) {
req["skipAwaitRollout"] = v
}
return req, nil
}
// marshalUpdateOSPolicyAssignmentUpdateOSPolicyAssignmentRequest converts the update into
// the final JSON request body.
func marshalUpdateOSPolicyAssignmentUpdateOSPolicyAssignmentRequest(c *Client, m map[string]interface{}) ([]byte, error) {
dcl.MoveMapEntry(
m,
[]string{"skipAwaitRollout"},
[]string{},
)
return json.Marshal(m)
}
type updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation struct {
// If the update operation has the REQUIRES_APPLY_OPTIONS trait, this will be populated.
// Usually it will be nil - this is to prevent us from accidentally depending on apply
// options, which should usually be unnecessary.
ApplyOptions []dcl.ApplyOption
FieldDiffs []*dcl.FieldDiff
}
// do creates a request and sends it to the appropriate URL. In most operations,
// do will transcribe a subset of the resource into a request object and send a
// PUT request to a single URL.
func (c *Client) listOSPolicyAssignmentRaw(ctx context.Context, r *OSPolicyAssignment, pageToken string, pageSize int32) ([]byte, error) {
u, err := r.urlNormalized().listURL(c.Config.BasePath)
if err != nil {
return nil, err
}
m := make(map[string]string)
if pageToken != "" {
m["pageToken"] = pageToken
}
if pageSize != OSPolicyAssignmentMaxPage {
m["pageSize"] = fmt.Sprintf("%v", pageSize)
}
u, err = dcl.AddQueryParams(u, m)
if err != nil {
return nil, err
}
resp, err := dcl.SendRequest(ctx, c.Config, "GET", u, &bytes.Buffer{}, c.Config.RetryProvider)
if err != nil {
return nil, err
}
defer resp.Response.Body.Close()
return ioutil.ReadAll(resp.Response.Body)
}
type listOSPolicyAssignmentOperation struct {
OsPolicyAssignments []map[string]interface{} `json:"osPolicyAssignments"`
Token string `json:"nextPageToken"`
}
func (c *Client) listOSPolicyAssignment(ctx context.Context, r *OSPolicyAssignment, pageToken string, pageSize int32) ([]*OSPolicyAssignment, string, error) {
b, err := c.listOSPolicyAssignmentRaw(ctx, r, pageToken, pageSize)
if err != nil {
return nil, "", err
}
var m listOSPolicyAssignmentOperation
if err := json.Unmarshal(b, &m); err != nil {
return nil, "", err
}
var l []*OSPolicyAssignment
for _, v := range m.OsPolicyAssignments {
res, err := unmarshalMapOSPolicyAssignment(v, c, r)
if err != nil {
return nil, m.Token, err
}
res.Project = r.Project
res.Location = r.Location
l = append(l, res)
}
return l, m.Token, nil
}
func (c *Client) deleteAllOSPolicyAssignment(ctx context.Context, f func(*OSPolicyAssignment) bool, resources []*OSPolicyAssignment) error {
var errors []string
for _, res := range resources {
if f(res) {
// We do not want deleteAll to fail on a deletion or else it will stop deleting other resources.
err := c.DeleteOSPolicyAssignment(ctx, res)
if err != nil {
errors = append(errors, err.Error())
}
}
}
if len(errors) > 0 {
return fmt.Errorf("%v", strings.Join(errors, "\n"))
} else {
return nil
}
}
type deleteOSPolicyAssignmentOperation struct{}
// Create operations are similar to Update operations, although they do not have
// specific request objects. The Create request object is the json encoding of
// the resource, which is modified by res.marshal to form the base request body.
type createOSPolicyAssignmentOperation struct {
response map[string]interface{}
}
func (op *createOSPolicyAssignmentOperation) FirstResponse() (map[string]interface{}, bool) {
return op.response, len(op.response) > 0
}
func (c *Client) getOSPolicyAssignmentRaw(ctx context.Context, r *OSPolicyAssignment) ([]byte, error) {
u, err := r.getURL(c.Config.BasePath)
if err != nil {
return nil, err
}
resp, err := dcl.SendRequest(ctx, c.Config, "GET", u, &bytes.Buffer{}, c.Config.RetryProvider)
if err != nil {
return nil, err
}
defer resp.Response.Body.Close()
b, err := ioutil.ReadAll(resp.Response.Body)
if err != nil {
return nil, err
}
return b, nil
}
func (c *Client) oSPolicyAssignmentDiffsForRawDesired(ctx context.Context, rawDesired *OSPolicyAssignment, opts ...dcl.ApplyOption) (initial, desired *OSPolicyAssignment, diffs []*dcl.FieldDiff, err error) {
c.Config.Logger.InfoWithContext(ctx, "Fetching initial state...")
// First, let us see if the user provided a state hint. If they did, we will start fetching based on that.
var fetchState *OSPolicyAssignment
if sh := dcl.FetchStateHint(opts); sh != nil {
if r, ok := sh.(*OSPolicyAssignment); !ok {
c.Config.Logger.WarningWithContextf(ctx, "Initial state hint was of the wrong type; expected OSPolicyAssignment, got %T", sh)
} else {
fetchState = r
}
}
if fetchState == nil {
fetchState = rawDesired
}
// 1.2: Retrieval of raw initial state from API
rawInitial, err := c.GetOSPolicyAssignment(ctx, fetchState)
if rawInitial == nil {
if !dcl.IsNotFound(err) {
c.Config.Logger.WarningWithContextf(ctx, "Failed to retrieve whether a OSPolicyAssignment resource already exists: %s", err)
return nil, nil, nil, fmt.Errorf("failed to retrieve OSPolicyAssignment resource: %v", err)
}
c.Config.Logger.InfoWithContext(ctx, "Found that OSPolicyAssignment resource did not exist.")
// Perform canonicalization to pick up defaults.
desired, err = canonicalizeOSPolicyAssignmentDesiredState(rawDesired, rawInitial)
return nil, desired, nil, err
}
c.Config.Logger.InfoWithContextf(ctx, "Found initial state for OSPolicyAssignment: %v", rawInitial)
c.Config.Logger.InfoWithContextf(ctx, "Initial desired state for OSPolicyAssignment: %v", rawDesired)
// The Get call applies postReadExtract and so the result may contain fields that are not part of API version.
if err := extractOSPolicyAssignmentFields(rawInitial); err != nil {
return nil, nil, nil, err
}
// 1.3: Canonicalize raw initial state into initial state.
initial, err = canonicalizeOSPolicyAssignmentInitialState(rawInitial, rawDesired)
if err != nil {
return nil, nil, nil, err
}
c.Config.Logger.InfoWithContextf(ctx, "Canonicalized initial state for OSPolicyAssignment: %v", initial)
// 1.4: Canonicalize raw desired state into desired state.
desired, err = canonicalizeOSPolicyAssignmentDesiredState(rawDesired, rawInitial, opts...)
if err != nil {
return nil, nil, nil, err
}
c.Config.Logger.InfoWithContextf(ctx, "Canonicalized desired state for OSPolicyAssignment: %v", desired)
// 2.1: Comparison of initial and desired state.
diffs, err = diffOSPolicyAssignment(c, desired, initial, opts...)
return initial, desired, diffs, err
}
func canonicalizeOSPolicyAssignmentInitialState(rawInitial, rawDesired *OSPolicyAssignment) (*OSPolicyAssignment, error) {
// TODO(magic-modules-eng): write canonicalizer once relevant traits are added.
return rawInitial, nil
}
/*
* Canonicalizers
*
* These are responsible for converting either a user-specified config or a
* GCP API response to a standard format that can be used for difference checking.
* */
func canonicalizeOSPolicyAssignmentDesiredState(rawDesired, rawInitial *OSPolicyAssignment, opts ...dcl.ApplyOption) (*OSPolicyAssignment, error) {
if rawInitial == nil {
// Since the initial state is empty, the desired state is all we have.
// We canonicalize the remaining nested objects with nil to pick up defaults.
rawDesired.InstanceFilter = canonicalizeOSPolicyAssignmentInstanceFilter(rawDesired.InstanceFilter, nil, opts...)
rawDesired.Rollout = canonicalizeOSPolicyAssignmentRollout(rawDesired.Rollout, nil, opts...)
return rawDesired, nil
}
canonicalDesired := &OSPolicyAssignment{}
if dcl.PartialSelfLinkToSelfLink(rawDesired.Name, rawInitial.Name) {
canonicalDesired.Name = rawInitial.Name
} else {
canonicalDesired.Name = rawDesired.Name
}
if dcl.StringCanonicalize(rawDesired.Description, rawInitial.Description) {
canonicalDesired.Description = rawInitial.Description
} else {
canonicalDesired.Description = rawDesired.Description
}
canonicalDesired.OSPolicies = canonicalizeOSPolicyAssignmentOSPoliciesSlice(rawDesired.OSPolicies, rawInitial.OSPolicies, opts...)
canonicalDesired.InstanceFilter = canonicalizeOSPolicyAssignmentInstanceFilter(rawDesired.InstanceFilter, rawInitial.InstanceFilter, opts...)
canonicalDesired.Rollout = canonicalizeOSPolicyAssignmentRollout(rawDesired.Rollout, rawInitial.Rollout, opts...)
if dcl.NameToSelfLink(rawDesired.Project, rawInitial.Project) {
canonicalDesired.Project = rawInitial.Project
} else {
canonicalDesired.Project = rawDesired.Project
}
if dcl.NameToSelfLink(rawDesired.Location, rawInitial.Location) {
canonicalDesired.Location = rawInitial.Location
} else {
canonicalDesired.Location = rawDesired.Location
}
if dcl.BoolCanonicalize(rawDesired.SkipAwaitRollout, rawInitial.SkipAwaitRollout) {
canonicalDesired.SkipAwaitRollout = rawInitial.SkipAwaitRollout
} else {
canonicalDesired.SkipAwaitRollout = rawDesired.SkipAwaitRollout
}
return canonicalDesired, nil
}
func canonicalizeOSPolicyAssignmentNewState(c *Client, rawNew, rawDesired *OSPolicyAssignment) (*OSPolicyAssignment, error) {
if dcl.IsEmptyValueIndirect(rawNew.Name) && dcl.IsEmptyValueIndirect(rawDesired.Name) {
rawNew.Name = rawDesired.Name
} else {
if dcl.PartialSelfLinkToSelfLink(rawDesired.Name, rawNew.Name) {
rawNew.Name = rawDesired.Name
}
}
if dcl.IsEmptyValueIndirect(rawNew.Description) && dcl.IsEmptyValueIndirect(rawDesired.Description) {
rawNew.Description = rawDesired.Description
} else {
if dcl.StringCanonicalize(rawDesired.Description, rawNew.Description) {
rawNew.Description = rawDesired.Description
}
}
if dcl.IsEmptyValueIndirect(rawNew.OSPolicies) && dcl.IsEmptyValueIndirect(rawDesired.OSPolicies) {
rawNew.OSPolicies = rawDesired.OSPolicies
} else {
rawNew.OSPolicies = canonicalizeNewOSPolicyAssignmentOSPoliciesSlice(c, rawDesired.OSPolicies, rawNew.OSPolicies)
}
if dcl.IsEmptyValueIndirect(rawNew.InstanceFilter) && dcl.IsEmptyValueIndirect(rawDesired.InstanceFilter) {
rawNew.InstanceFilter = rawDesired.InstanceFilter
} else {
rawNew.InstanceFilter = canonicalizeNewOSPolicyAssignmentInstanceFilter(c, rawDesired.InstanceFilter, rawNew.InstanceFilter)
}
if dcl.IsEmptyValueIndirect(rawNew.Rollout) && dcl.IsEmptyValueIndirect(rawDesired.Rollout) {
rawNew.Rollout = rawDesired.Rollout
} else {
rawNew.Rollout = canonicalizeNewOSPolicyAssignmentRollout(c, rawDesired.Rollout, rawNew.Rollout)
}
if dcl.IsEmptyValueIndirect(rawNew.RevisionId) && dcl.IsEmptyValueIndirect(rawDesired.RevisionId) {
rawNew.RevisionId = rawDesired.RevisionId
} else {
if dcl.StringCanonicalize(rawDesired.RevisionId, rawNew.RevisionId) {
rawNew.RevisionId = rawDesired.RevisionId
}
}
if dcl.IsEmptyValueIndirect(rawNew.RevisionCreateTime) && dcl.IsEmptyValueIndirect(rawDesired.RevisionCreateTime) {
rawNew.RevisionCreateTime = rawDesired.RevisionCreateTime
} else {
}
if dcl.IsEmptyValueIndirect(rawNew.Etag) && dcl.IsEmptyValueIndirect(rawDesired.Etag) {
rawNew.Etag = rawDesired.Etag
} else {
if dcl.StringCanonicalize(rawDesired.Etag, rawNew.Etag) {
rawNew.Etag = rawDesired.Etag
}
}
if dcl.IsEmptyValueIndirect(rawNew.RolloutState) && dcl.IsEmptyValueIndirect(rawDesired.RolloutState) {
rawNew.RolloutState = rawDesired.RolloutState
} else {
}
if dcl.IsEmptyValueIndirect(rawNew.Baseline) && dcl.IsEmptyValueIndirect(rawDesired.Baseline) {
rawNew.Baseline = rawDesired.Baseline
} else {
if dcl.BoolCanonicalize(rawDesired.Baseline, rawNew.Baseline) {
rawNew.Baseline = rawDesired.Baseline
}
}
if dcl.IsEmptyValueIndirect(rawNew.Deleted) && dcl.IsEmptyValueIndirect(rawDesired.Deleted) {
rawNew.Deleted = rawDesired.Deleted
} else {
if dcl.BoolCanonicalize(rawDesired.Deleted, rawNew.Deleted) {
rawNew.Deleted = rawDesired.Deleted
}
}
if dcl.IsEmptyValueIndirect(rawNew.Reconciling) && dcl.IsEmptyValueIndirect(rawDesired.Reconciling) {
rawNew.Reconciling = rawDesired.Reconciling
} else {
if dcl.BoolCanonicalize(rawDesired.Reconciling, rawNew.Reconciling) {
rawNew.Reconciling = rawDesired.Reconciling
}
}
if dcl.IsEmptyValueIndirect(rawNew.Uid) && dcl.IsEmptyValueIndirect(rawDesired.Uid) {
rawNew.Uid = rawDesired.Uid
} else {
if dcl.StringCanonicalize(rawDesired.Uid, rawNew.Uid) {
rawNew.Uid = rawDesired.Uid
}
}
rawNew.Project = rawDesired.Project
rawNew.Location = rawDesired.Location
if dcl.IsEmptyValueIndirect(rawNew.SkipAwaitRollout) && dcl.IsEmptyValueIndirect(rawDesired.SkipAwaitRollout) {
rawNew.SkipAwaitRollout = rawDesired.SkipAwaitRollout
} else {
rawNew.SkipAwaitRollout = rawDesired.SkipAwaitRollout
}
return rawNew, nil
}
func canonicalizeOSPolicyAssignmentOSPolicies(des, initial *OSPolicyAssignmentOSPolicies, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPolicies {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPolicies{}
if dcl.StringCanonicalize(des.Id, initial.Id) || dcl.IsZeroValue(des.Id) {
cDes.Id = initial.Id
} else {
cDes.Id = des.Id
}
if dcl.StringCanonicalize(des.Description, initial.Description) || dcl.IsZeroValue(des.Description) {
cDes.Description = initial.Description
} else {
cDes.Description = des.Description
}
if dcl.IsZeroValue(des.Mode) || (dcl.IsEmptyValueIndirect(des.Mode) && dcl.IsEmptyValueIndirect(initial.Mode)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Mode = initial.Mode
} else {
cDes.Mode = des.Mode
}
cDes.ResourceGroups = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsSlice(des.ResourceGroups, initial.ResourceGroups, opts...)
if dcl.BoolCanonicalize(des.AllowNoResourceGroupMatch, initial.AllowNoResourceGroupMatch) || dcl.IsZeroValue(des.AllowNoResourceGroupMatch) {
cDes.AllowNoResourceGroupMatch = initial.AllowNoResourceGroupMatch
} else {
cDes.AllowNoResourceGroupMatch = des.AllowNoResourceGroupMatch
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesSlice(des, initial []OSPolicyAssignmentOSPolicies, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPolicies {
if des == nil {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPolicies, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPolicies(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPolicies, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPolicies(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPolicies(c *Client, des, nw *OSPolicyAssignmentOSPolicies) *OSPolicyAssignmentOSPolicies {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPolicies while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Id, nw.Id) {
nw.Id = des.Id
}
if dcl.StringCanonicalize(des.Description, nw.Description) {
nw.Description = des.Description
}
nw.ResourceGroups = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsSlice(c, des.ResourceGroups, nw.ResourceGroups)
if dcl.BoolCanonicalize(des.AllowNoResourceGroupMatch, nw.AllowNoResourceGroupMatch) {
nw.AllowNoResourceGroupMatch = des.AllowNoResourceGroupMatch
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesSet(c *Client, des, nw []OSPolicyAssignmentOSPolicies) []OSPolicyAssignmentOSPolicies {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPolicies
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPolicies(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesSlice(c *Client, des, nw []OSPolicyAssignmentOSPolicies) []OSPolicyAssignmentOSPolicies {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPolicies
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPolicies(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroups(des, initial *OSPolicyAssignmentOSPoliciesResourceGroups, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroups {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroups{}
cDes.InventoryFilters = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersSlice(des.InventoryFilters, initial.InventoryFilters, opts...)
cDes.Resources = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesSlice(des.Resources, initial.Resources, opts...)
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroups, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroups {
if des == nil {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroups, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroups(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroups, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroups(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroups(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroups) *OSPolicyAssignmentOSPoliciesResourceGroups {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroups while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.InventoryFilters = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersSlice(c, des.InventoryFilters, nw.InventoryFilters)
nw.Resources = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesSlice(c, des.Resources, nw.Resources)
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroups) []OSPolicyAssignmentOSPoliciesResourceGroups {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroups
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroups(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroups) []OSPolicyAssignmentOSPoliciesResourceGroups {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroups
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroups(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters{}
if dcl.StringCanonicalize(des.OSShortName, initial.OSShortName) || dcl.IsZeroValue(des.OSShortName) {
cDes.OSShortName = initial.OSShortName
} else {
cDes.OSShortName = des.OSShortName
}
if dcl.StringCanonicalize(des.OSVersion, initial.OSVersion) || dcl.IsZeroValue(des.OSVersion) {
cDes.OSVersion = initial.OSVersion
} else {
cDes.OSVersion = des.OSVersion
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters {
if des == nil {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.OSShortName, nw.OSShortName) {
nw.OSShortName = des.OSShortName
}
if dcl.StringCanonicalize(des.OSVersion, nw.OSVersion) {
nw.OSVersion = des.OSVersion
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResources(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResources, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResources {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.Pkg != nil || (initial != nil && initial.Pkg != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Repository, des.Exec, des.File) {
des.Pkg = nil
if initial != nil {
initial.Pkg = nil
}
}
}
if des.Repository != nil || (initial != nil && initial.Repository != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Pkg, des.Exec, des.File) {
des.Repository = nil
if initial != nil {
initial.Repository = nil
}
}
}
if des.Exec != nil || (initial != nil && initial.Exec != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Pkg, des.Repository, des.File) {
des.Exec = nil
if initial != nil {
initial.Exec = nil
}
}
}
if des.File != nil || (initial != nil && initial.File != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Pkg, des.Repository, des.Exec) {
des.File = nil
if initial != nil {
initial.File = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResources{}
if dcl.StringCanonicalize(des.Id, initial.Id) || dcl.IsZeroValue(des.Id) {
cDes.Id = initial.Id
} else {
cDes.Id = des.Id
}
cDes.Pkg = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(des.Pkg, initial.Pkg, opts...)
cDes.Repository = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(des.Repository, initial.Repository, opts...)
cDes.Exec = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(des.Exec, initial.Exec, opts...)
cDes.File = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(des.File, initial.File, opts...)
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResources, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResources {
if des == nil {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResources, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResources(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResources, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResources(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResources(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResources) *OSPolicyAssignmentOSPoliciesResourceGroupsResources {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResources while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Id, nw.Id) {
nw.Id = des.Id
}
nw.Pkg = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c, des.Pkg, nw.Pkg)
nw.Repository = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c, des.Repository, nw.Repository)
nw.Exec = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c, des.Exec, nw.Exec)
nw.File = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c, des.File, nw.File)
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResources) []OSPolicyAssignmentOSPoliciesResourceGroupsResources {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResources
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResources(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResources) []OSPolicyAssignmentOSPoliciesResourceGroupsResources {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResources
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResources(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.Apt != nil || (initial != nil && initial.Apt != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Deb, des.Yum, des.Zypper, des.Rpm, des.Googet, des.Msi) {
des.Apt = nil
if initial != nil {
initial.Apt = nil
}
}
}
if des.Deb != nil || (initial != nil && initial.Deb != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Apt, des.Yum, des.Zypper, des.Rpm, des.Googet, des.Msi) {
des.Deb = nil
if initial != nil {
initial.Deb = nil
}
}
}
if des.Yum != nil || (initial != nil && initial.Yum != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Apt, des.Deb, des.Zypper, des.Rpm, des.Googet, des.Msi) {
des.Yum = nil
if initial != nil {
initial.Yum = nil
}
}
}
if des.Zypper != nil || (initial != nil && initial.Zypper != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Apt, des.Deb, des.Yum, des.Rpm, des.Googet, des.Msi) {
des.Zypper = nil
if initial != nil {
initial.Zypper = nil
}
}
}
if des.Rpm != nil || (initial != nil && initial.Rpm != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Apt, des.Deb, des.Yum, des.Zypper, des.Googet, des.Msi) {
des.Rpm = nil
if initial != nil {
initial.Rpm = nil
}
}
}
if des.Googet != nil || (initial != nil && initial.Googet != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Apt, des.Deb, des.Yum, des.Zypper, des.Rpm, des.Msi) {
des.Googet = nil
if initial != nil {
initial.Googet = nil
}
}
}
if des.Msi != nil || (initial != nil && initial.Msi != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Apt, des.Deb, des.Yum, des.Zypper, des.Rpm, des.Googet) {
des.Msi = nil
if initial != nil {
initial.Msi = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg{}
if dcl.IsZeroValue(des.DesiredState) || (dcl.IsEmptyValueIndirect(des.DesiredState) && dcl.IsEmptyValueIndirect(initial.DesiredState)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.DesiredState = initial.DesiredState
} else {
cDes.DesiredState = des.DesiredState
}
cDes.Apt = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(des.Apt, initial.Apt, opts...)
cDes.Deb = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(des.Deb, initial.Deb, opts...)
cDes.Yum = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(des.Yum, initial.Yum, opts...)
cDes.Zypper = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(des.Zypper, initial.Zypper, opts...)
cDes.Rpm = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(des.Rpm, initial.Rpm, opts...)
cDes.Googet = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(des.Googet, initial.Googet, opts...)
cDes.Msi = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(des.Msi, initial.Msi, opts...)
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Apt = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c, des.Apt, nw.Apt)
nw.Deb = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c, des.Deb, nw.Deb)
nw.Yum = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c, des.Yum, nw.Yum)
nw.Zypper = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c, des.Zypper, nw.Zypper)
nw.Rpm = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c, des.Rpm, nw.Rpm)
nw.Googet = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c, des.Googet, nw.Googet)
nw.Msi = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c, des.Msi, nw.Msi)
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt{}
if dcl.StringCanonicalize(des.Name, initial.Name) || dcl.IsZeroValue(des.Name) {
cDes.Name = initial.Name
} else {
cDes.Name = des.Name
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Name, nw.Name) {
nw.Name = des.Name
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb{}
cDes.Source = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(des.Source, initial.Source, opts...)
if dcl.BoolCanonicalize(des.PullDeps, initial.PullDeps) || dcl.IsZeroValue(des.PullDeps) {
cDes.PullDeps = initial.PullDeps
} else {
cDes.PullDeps = des.PullDeps
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Source = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c, des.Source, nw.Source)
if dcl.BoolCanonicalize(des.PullDeps, nw.PullDeps) {
nw.PullDeps = des.PullDeps
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.Remote != nil || (initial != nil && initial.Remote != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Gcs, des.LocalPath) {
des.Remote = nil
if initial != nil {
initial.Remote = nil
}
}
}
if des.Gcs != nil || (initial != nil && initial.Gcs != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.LocalPath) {
des.Gcs = nil
if initial != nil {
initial.Gcs = nil
}
}
}
if des.LocalPath != nil || (initial != nil && initial.LocalPath != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.Gcs) {
des.LocalPath = nil
if initial != nil {
initial.LocalPath = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource{}
cDes.Remote = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(des.Remote, initial.Remote, opts...)
cDes.Gcs = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(des.Gcs, initial.Gcs, opts...)
if dcl.StringCanonicalize(des.LocalPath, initial.LocalPath) || dcl.IsZeroValue(des.LocalPath) {
cDes.LocalPath = initial.LocalPath
} else {
cDes.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, initial.AllowInsecure) || dcl.IsZeroValue(des.AllowInsecure) {
cDes.AllowInsecure = initial.AllowInsecure
} else {
cDes.AllowInsecure = des.AllowInsecure
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Remote = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c, des.Remote, nw.Remote)
nw.Gcs = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c, des.Gcs, nw.Gcs)
if dcl.StringCanonicalize(des.LocalPath, nw.LocalPath) {
nw.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, nw.AllowInsecure) {
nw.AllowInsecure = des.AllowInsecure
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote{}
if dcl.StringCanonicalize(des.Uri, initial.Uri) || dcl.IsZeroValue(des.Uri) {
cDes.Uri = initial.Uri
} else {
cDes.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, initial.Sha256Checksum) || dcl.IsZeroValue(des.Sha256Checksum) {
cDes.Sha256Checksum = initial.Sha256Checksum
} else {
cDes.Sha256Checksum = des.Sha256Checksum
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Uri, nw.Uri) {
nw.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, nw.Sha256Checksum) {
nw.Sha256Checksum = des.Sha256Checksum
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs{}
if dcl.StringCanonicalize(des.Bucket, initial.Bucket) || dcl.IsZeroValue(des.Bucket) {
cDes.Bucket = initial.Bucket
} else {
cDes.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, initial.Object) || dcl.IsZeroValue(des.Object) {
cDes.Object = initial.Object
} else {
cDes.Object = des.Object
}
if dcl.IsZeroValue(des.Generation) || (dcl.IsEmptyValueIndirect(des.Generation) && dcl.IsEmptyValueIndirect(initial.Generation)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Generation = initial.Generation
} else {
cDes.Generation = des.Generation
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Bucket, nw.Bucket) {
nw.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, nw.Object) {
nw.Object = des.Object
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum{}
if dcl.StringCanonicalize(des.Name, initial.Name) || dcl.IsZeroValue(des.Name) {
cDes.Name = initial.Name
} else {
cDes.Name = des.Name
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Name, nw.Name) {
nw.Name = des.Name
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper{}
if dcl.StringCanonicalize(des.Name, initial.Name) || dcl.IsZeroValue(des.Name) {
cDes.Name = initial.Name
} else {
cDes.Name = des.Name
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Name, nw.Name) {
nw.Name = des.Name
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm{}
cDes.Source = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(des.Source, initial.Source, opts...)
if dcl.BoolCanonicalize(des.PullDeps, initial.PullDeps) || dcl.IsZeroValue(des.PullDeps) {
cDes.PullDeps = initial.PullDeps
} else {
cDes.PullDeps = des.PullDeps
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Source = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c, des.Source, nw.Source)
if dcl.BoolCanonicalize(des.PullDeps, nw.PullDeps) {
nw.PullDeps = des.PullDeps
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.Remote != nil || (initial != nil && initial.Remote != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Gcs, des.LocalPath) {
des.Remote = nil
if initial != nil {
initial.Remote = nil
}
}
}
if des.Gcs != nil || (initial != nil && initial.Gcs != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.LocalPath) {
des.Gcs = nil
if initial != nil {
initial.Gcs = nil
}
}
}
if des.LocalPath != nil || (initial != nil && initial.LocalPath != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.Gcs) {
des.LocalPath = nil
if initial != nil {
initial.LocalPath = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource{}
cDes.Remote = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(des.Remote, initial.Remote, opts...)
cDes.Gcs = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(des.Gcs, initial.Gcs, opts...)
if dcl.StringCanonicalize(des.LocalPath, initial.LocalPath) || dcl.IsZeroValue(des.LocalPath) {
cDes.LocalPath = initial.LocalPath
} else {
cDes.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, initial.AllowInsecure) || dcl.IsZeroValue(des.AllowInsecure) {
cDes.AllowInsecure = initial.AllowInsecure
} else {
cDes.AllowInsecure = des.AllowInsecure
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Remote = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c, des.Remote, nw.Remote)
nw.Gcs = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c, des.Gcs, nw.Gcs)
if dcl.StringCanonicalize(des.LocalPath, nw.LocalPath) {
nw.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, nw.AllowInsecure) {
nw.AllowInsecure = des.AllowInsecure
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote{}
if dcl.StringCanonicalize(des.Uri, initial.Uri) || dcl.IsZeroValue(des.Uri) {
cDes.Uri = initial.Uri
} else {
cDes.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, initial.Sha256Checksum) || dcl.IsZeroValue(des.Sha256Checksum) {
cDes.Sha256Checksum = initial.Sha256Checksum
} else {
cDes.Sha256Checksum = des.Sha256Checksum
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Uri, nw.Uri) {
nw.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, nw.Sha256Checksum) {
nw.Sha256Checksum = des.Sha256Checksum
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs{}
if dcl.StringCanonicalize(des.Bucket, initial.Bucket) || dcl.IsZeroValue(des.Bucket) {
cDes.Bucket = initial.Bucket
} else {
cDes.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, initial.Object) || dcl.IsZeroValue(des.Object) {
cDes.Object = initial.Object
} else {
cDes.Object = des.Object
}
if dcl.IsZeroValue(des.Generation) || (dcl.IsEmptyValueIndirect(des.Generation) && dcl.IsEmptyValueIndirect(initial.Generation)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Generation = initial.Generation
} else {
cDes.Generation = des.Generation
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Bucket, nw.Bucket) {
nw.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, nw.Object) {
nw.Object = des.Object
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget{}
if dcl.StringCanonicalize(des.Name, initial.Name) || dcl.IsZeroValue(des.Name) {
cDes.Name = initial.Name
} else {
cDes.Name = des.Name
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Name, nw.Name) {
nw.Name = des.Name
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi{}
cDes.Source = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(des.Source, initial.Source, opts...)
if dcl.StringArrayCanonicalize(des.Properties, initial.Properties) {
cDes.Properties = initial.Properties
} else {
cDes.Properties = des.Properties
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Source = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c, des.Source, nw.Source)
if dcl.StringArrayCanonicalize(des.Properties, nw.Properties) {
nw.Properties = des.Properties
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.Remote != nil || (initial != nil && initial.Remote != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Gcs, des.LocalPath) {
des.Remote = nil
if initial != nil {
initial.Remote = nil
}
}
}
if des.Gcs != nil || (initial != nil && initial.Gcs != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.LocalPath) {
des.Gcs = nil
if initial != nil {
initial.Gcs = nil
}
}
}
if des.LocalPath != nil || (initial != nil && initial.LocalPath != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.Gcs) {
des.LocalPath = nil
if initial != nil {
initial.LocalPath = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource{}
cDes.Remote = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(des.Remote, initial.Remote, opts...)
cDes.Gcs = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(des.Gcs, initial.Gcs, opts...)
if dcl.StringCanonicalize(des.LocalPath, initial.LocalPath) || dcl.IsZeroValue(des.LocalPath) {
cDes.LocalPath = initial.LocalPath
} else {
cDes.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, initial.AllowInsecure) || dcl.IsZeroValue(des.AllowInsecure) {
cDes.AllowInsecure = initial.AllowInsecure
} else {
cDes.AllowInsecure = des.AllowInsecure
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Remote = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c, des.Remote, nw.Remote)
nw.Gcs = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c, des.Gcs, nw.Gcs)
if dcl.StringCanonicalize(des.LocalPath, nw.LocalPath) {
nw.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, nw.AllowInsecure) {
nw.AllowInsecure = des.AllowInsecure
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote{}
if dcl.StringCanonicalize(des.Uri, initial.Uri) || dcl.IsZeroValue(des.Uri) {
cDes.Uri = initial.Uri
} else {
cDes.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, initial.Sha256Checksum) || dcl.IsZeroValue(des.Sha256Checksum) {
cDes.Sha256Checksum = initial.Sha256Checksum
} else {
cDes.Sha256Checksum = des.Sha256Checksum
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Uri, nw.Uri) {
nw.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, nw.Sha256Checksum) {
nw.Sha256Checksum = des.Sha256Checksum
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs{}
if dcl.StringCanonicalize(des.Bucket, initial.Bucket) || dcl.IsZeroValue(des.Bucket) {
cDes.Bucket = initial.Bucket
} else {
cDes.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, initial.Object) || dcl.IsZeroValue(des.Object) {
cDes.Object = initial.Object
} else {
cDes.Object = des.Object
}
if dcl.IsZeroValue(des.Generation) || (dcl.IsEmptyValueIndirect(des.Generation) && dcl.IsEmptyValueIndirect(initial.Generation)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Generation = initial.Generation
} else {
cDes.Generation = des.Generation
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Bucket, nw.Bucket) {
nw.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, nw.Object) {
nw.Object = des.Object
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.Apt != nil || (initial != nil && initial.Apt != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Yum, des.Zypper, des.Goo) {
des.Apt = nil
if initial != nil {
initial.Apt = nil
}
}
}
if des.Yum != nil || (initial != nil && initial.Yum != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Apt, des.Zypper, des.Goo) {
des.Yum = nil
if initial != nil {
initial.Yum = nil
}
}
}
if des.Zypper != nil || (initial != nil && initial.Zypper != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Apt, des.Yum, des.Goo) {
des.Zypper = nil
if initial != nil {
initial.Zypper = nil
}
}
}
if des.Goo != nil || (initial != nil && initial.Goo != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Apt, des.Yum, des.Zypper) {
des.Goo = nil
if initial != nil {
initial.Goo = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository{}
cDes.Apt = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(des.Apt, initial.Apt, opts...)
cDes.Yum = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(des.Yum, initial.Yum, opts...)
cDes.Zypper = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(des.Zypper, initial.Zypper, opts...)
cDes.Goo = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(des.Goo, initial.Goo, opts...)
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositorySlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Apt = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c, des.Apt, nw.Apt)
nw.Yum = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c, des.Yum, nw.Yum)
nw.Zypper = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c, des.Zypper, nw.Zypper)
nw.Goo = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c, des.Goo, nw.Goo)
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositorySet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositorySlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt{}
if dcl.IsZeroValue(des.ArchiveType) || (dcl.IsEmptyValueIndirect(des.ArchiveType) && dcl.IsEmptyValueIndirect(initial.ArchiveType)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.ArchiveType = initial.ArchiveType
} else {
cDes.ArchiveType = des.ArchiveType
}
if dcl.StringCanonicalize(des.Uri, initial.Uri) || dcl.IsZeroValue(des.Uri) {
cDes.Uri = initial.Uri
} else {
cDes.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Distribution, initial.Distribution) || dcl.IsZeroValue(des.Distribution) {
cDes.Distribution = initial.Distribution
} else {
cDes.Distribution = des.Distribution
}
if dcl.StringArrayCanonicalize(des.Components, initial.Components) {
cDes.Components = initial.Components
} else {
cDes.Components = des.Components
}
if dcl.StringCanonicalize(des.GpgKey, initial.GpgKey) || dcl.IsZeroValue(des.GpgKey) {
cDes.GpgKey = initial.GpgKey
} else {
cDes.GpgKey = des.GpgKey
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Uri, nw.Uri) {
nw.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Distribution, nw.Distribution) {
nw.Distribution = des.Distribution
}
if dcl.StringArrayCanonicalize(des.Components, nw.Components) {
nw.Components = des.Components
}
if dcl.StringCanonicalize(des.GpgKey, nw.GpgKey) {
nw.GpgKey = des.GpgKey
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum{}
if dcl.StringCanonicalize(des.Id, initial.Id) || dcl.IsZeroValue(des.Id) {
cDes.Id = initial.Id
} else {
cDes.Id = des.Id
}
if dcl.StringCanonicalize(des.DisplayName, initial.DisplayName) || dcl.IsZeroValue(des.DisplayName) {
cDes.DisplayName = initial.DisplayName
} else {
cDes.DisplayName = des.DisplayName
}
if dcl.StringCanonicalize(des.BaseUrl, initial.BaseUrl) || dcl.IsZeroValue(des.BaseUrl) {
cDes.BaseUrl = initial.BaseUrl
} else {
cDes.BaseUrl = des.BaseUrl
}
if dcl.StringArrayCanonicalize(des.GpgKeys, initial.GpgKeys) {
cDes.GpgKeys = initial.GpgKeys
} else {
cDes.GpgKeys = des.GpgKeys
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Id, nw.Id) {
nw.Id = des.Id
}
if dcl.StringCanonicalize(des.DisplayName, nw.DisplayName) {
nw.DisplayName = des.DisplayName
}
if dcl.StringCanonicalize(des.BaseUrl, nw.BaseUrl) {
nw.BaseUrl = des.BaseUrl
}
if dcl.StringArrayCanonicalize(des.GpgKeys, nw.GpgKeys) {
nw.GpgKeys = des.GpgKeys
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper{}
if dcl.StringCanonicalize(des.Id, initial.Id) || dcl.IsZeroValue(des.Id) {
cDes.Id = initial.Id
} else {
cDes.Id = des.Id
}
if dcl.StringCanonicalize(des.DisplayName, initial.DisplayName) || dcl.IsZeroValue(des.DisplayName) {
cDes.DisplayName = initial.DisplayName
} else {
cDes.DisplayName = des.DisplayName
}
if dcl.StringCanonicalize(des.BaseUrl, initial.BaseUrl) || dcl.IsZeroValue(des.BaseUrl) {
cDes.BaseUrl = initial.BaseUrl
} else {
cDes.BaseUrl = des.BaseUrl
}
if dcl.StringArrayCanonicalize(des.GpgKeys, initial.GpgKeys) {
cDes.GpgKeys = initial.GpgKeys
} else {
cDes.GpgKeys = des.GpgKeys
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Id, nw.Id) {
nw.Id = des.Id
}
if dcl.StringCanonicalize(des.DisplayName, nw.DisplayName) {
nw.DisplayName = des.DisplayName
}
if dcl.StringCanonicalize(des.BaseUrl, nw.BaseUrl) {
nw.BaseUrl = des.BaseUrl
}
if dcl.StringArrayCanonicalize(des.GpgKeys, nw.GpgKeys) {
nw.GpgKeys = des.GpgKeys
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo{}
if dcl.StringCanonicalize(des.Name, initial.Name) || dcl.IsZeroValue(des.Name) {
cDes.Name = initial.Name
} else {
cDes.Name = des.Name
}
if dcl.StringCanonicalize(des.Url, initial.Url) || dcl.IsZeroValue(des.Url) {
cDes.Url = initial.Url
} else {
cDes.Url = des.Url
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Name, nw.Name) {
nw.Name = des.Name
}
if dcl.StringCanonicalize(des.Url, nw.Url) {
nw.Url = des.Url
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec{}
cDes.Validate = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(des.Validate, initial.Validate, opts...)
cDes.Enforce = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(des.Enforce, initial.Enforce, opts...)
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Validate = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c, des.Validate, nw.Validate)
nw.Enforce = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c, des.Enforce, nw.Enforce)
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.File != nil || (initial != nil && initial.File != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Script) {
des.File = nil
if initial != nil {
initial.File = nil
}
}
}
if des.Script != nil || (initial != nil && initial.Script != nil) {
// Check if anything else is set.
if dcl.AnySet(des.File) {
des.Script = nil
if initial != nil {
initial.Script = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate{}
cDes.File = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(des.File, initial.File, opts...)
if dcl.StringCanonicalize(des.Script, initial.Script) || dcl.IsZeroValue(des.Script) {
cDes.Script = initial.Script
} else {
cDes.Script = des.Script
}
if dcl.StringArrayCanonicalize(des.Args, initial.Args) {
cDes.Args = initial.Args
} else {
cDes.Args = des.Args
}
if dcl.IsZeroValue(des.Interpreter) || (dcl.IsEmptyValueIndirect(des.Interpreter) && dcl.IsEmptyValueIndirect(initial.Interpreter)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Interpreter = initial.Interpreter
} else {
cDes.Interpreter = des.Interpreter
}
if dcl.StringCanonicalize(des.OutputFilePath, initial.OutputFilePath) || dcl.IsZeroValue(des.OutputFilePath) {
cDes.OutputFilePath = initial.OutputFilePath
} else {
cDes.OutputFilePath = des.OutputFilePath
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.File = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c, des.File, nw.File)
if dcl.StringCanonicalize(des.Script, nw.Script) {
nw.Script = des.Script
}
if dcl.StringArrayCanonicalize(des.Args, nw.Args) {
nw.Args = des.Args
}
if dcl.StringCanonicalize(des.OutputFilePath, nw.OutputFilePath) {
nw.OutputFilePath = des.OutputFilePath
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.Remote != nil || (initial != nil && initial.Remote != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Gcs, des.LocalPath) {
des.Remote = nil
if initial != nil {
initial.Remote = nil
}
}
}
if des.Gcs != nil || (initial != nil && initial.Gcs != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.LocalPath) {
des.Gcs = nil
if initial != nil {
initial.Gcs = nil
}
}
}
if des.LocalPath != nil || (initial != nil && initial.LocalPath != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.Gcs) {
des.LocalPath = nil
if initial != nil {
initial.LocalPath = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile{}
cDes.Remote = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(des.Remote, initial.Remote, opts...)
cDes.Gcs = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(des.Gcs, initial.Gcs, opts...)
if dcl.StringCanonicalize(des.LocalPath, initial.LocalPath) || dcl.IsZeroValue(des.LocalPath) {
cDes.LocalPath = initial.LocalPath
} else {
cDes.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, initial.AllowInsecure) || dcl.IsZeroValue(des.AllowInsecure) {
cDes.AllowInsecure = initial.AllowInsecure
} else {
cDes.AllowInsecure = des.AllowInsecure
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Remote = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c, des.Remote, nw.Remote)
nw.Gcs = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c, des.Gcs, nw.Gcs)
if dcl.StringCanonicalize(des.LocalPath, nw.LocalPath) {
nw.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, nw.AllowInsecure) {
nw.AllowInsecure = des.AllowInsecure
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote{}
if dcl.StringCanonicalize(des.Uri, initial.Uri) || dcl.IsZeroValue(des.Uri) {
cDes.Uri = initial.Uri
} else {
cDes.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, initial.Sha256Checksum) || dcl.IsZeroValue(des.Sha256Checksum) {
cDes.Sha256Checksum = initial.Sha256Checksum
} else {
cDes.Sha256Checksum = des.Sha256Checksum
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Uri, nw.Uri) {
nw.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, nw.Sha256Checksum) {
nw.Sha256Checksum = des.Sha256Checksum
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs{}
if dcl.StringCanonicalize(des.Bucket, initial.Bucket) || dcl.IsZeroValue(des.Bucket) {
cDes.Bucket = initial.Bucket
} else {
cDes.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, initial.Object) || dcl.IsZeroValue(des.Object) {
cDes.Object = initial.Object
} else {
cDes.Object = des.Object
}
if dcl.IsZeroValue(des.Generation) || (dcl.IsEmptyValueIndirect(des.Generation) && dcl.IsEmptyValueIndirect(initial.Generation)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Generation = initial.Generation
} else {
cDes.Generation = des.Generation
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Bucket, nw.Bucket) {
nw.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, nw.Object) {
nw.Object = des.Object
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.File != nil || (initial != nil && initial.File != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Script) {
des.File = nil
if initial != nil {
initial.File = nil
}
}
}
if des.Script != nil || (initial != nil && initial.Script != nil) {
// Check if anything else is set.
if dcl.AnySet(des.File) {
des.Script = nil
if initial != nil {
initial.Script = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce{}
cDes.File = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(des.File, initial.File, opts...)
if dcl.StringCanonicalize(des.Script, initial.Script) || dcl.IsZeroValue(des.Script) {
cDes.Script = initial.Script
} else {
cDes.Script = des.Script
}
if dcl.StringArrayCanonicalize(des.Args, initial.Args) {
cDes.Args = initial.Args
} else {
cDes.Args = des.Args
}
if dcl.IsZeroValue(des.Interpreter) || (dcl.IsEmptyValueIndirect(des.Interpreter) && dcl.IsEmptyValueIndirect(initial.Interpreter)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Interpreter = initial.Interpreter
} else {
cDes.Interpreter = des.Interpreter
}
if dcl.StringCanonicalize(des.OutputFilePath, initial.OutputFilePath) || dcl.IsZeroValue(des.OutputFilePath) {
cDes.OutputFilePath = initial.OutputFilePath
} else {
cDes.OutputFilePath = des.OutputFilePath
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.File = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c, des.File, nw.File)
if dcl.StringCanonicalize(des.Script, nw.Script) {
nw.Script = des.Script
}
if dcl.StringArrayCanonicalize(des.Args, nw.Args) {
nw.Args = des.Args
}
if dcl.StringCanonicalize(des.OutputFilePath, nw.OutputFilePath) {
nw.OutputFilePath = des.OutputFilePath
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.Remote != nil || (initial != nil && initial.Remote != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Gcs, des.LocalPath) {
des.Remote = nil
if initial != nil {
initial.Remote = nil
}
}
}
if des.Gcs != nil || (initial != nil && initial.Gcs != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.LocalPath) {
des.Gcs = nil
if initial != nil {
initial.Gcs = nil
}
}
}
if des.LocalPath != nil || (initial != nil && initial.LocalPath != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.Gcs) {
des.LocalPath = nil
if initial != nil {
initial.LocalPath = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile{}
cDes.Remote = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(des.Remote, initial.Remote, opts...)
cDes.Gcs = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(des.Gcs, initial.Gcs, opts...)
if dcl.StringCanonicalize(des.LocalPath, initial.LocalPath) || dcl.IsZeroValue(des.LocalPath) {
cDes.LocalPath = initial.LocalPath
} else {
cDes.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, initial.AllowInsecure) || dcl.IsZeroValue(des.AllowInsecure) {
cDes.AllowInsecure = initial.AllowInsecure
} else {
cDes.AllowInsecure = des.AllowInsecure
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Remote = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c, des.Remote, nw.Remote)
nw.Gcs = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c, des.Gcs, nw.Gcs)
if dcl.StringCanonicalize(des.LocalPath, nw.LocalPath) {
nw.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, nw.AllowInsecure) {
nw.AllowInsecure = des.AllowInsecure
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote{}
if dcl.StringCanonicalize(des.Uri, initial.Uri) || dcl.IsZeroValue(des.Uri) {
cDes.Uri = initial.Uri
} else {
cDes.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, initial.Sha256Checksum) || dcl.IsZeroValue(des.Sha256Checksum) {
cDes.Sha256Checksum = initial.Sha256Checksum
} else {
cDes.Sha256Checksum = des.Sha256Checksum
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Uri, nw.Uri) {
nw.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, nw.Sha256Checksum) {
nw.Sha256Checksum = des.Sha256Checksum
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs{}
if dcl.StringCanonicalize(des.Bucket, initial.Bucket) || dcl.IsZeroValue(des.Bucket) {
cDes.Bucket = initial.Bucket
} else {
cDes.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, initial.Object) || dcl.IsZeroValue(des.Object) {
cDes.Object = initial.Object
} else {
cDes.Object = des.Object
}
if dcl.IsZeroValue(des.Generation) || (dcl.IsEmptyValueIndirect(des.Generation) && dcl.IsEmptyValueIndirect(initial.Generation)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Generation = initial.Generation
} else {
cDes.Generation = des.Generation
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Bucket, nw.Bucket) {
nw.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, nw.Object) {
nw.Object = des.Object
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.File != nil || (initial != nil && initial.File != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Content) {
des.File = nil
if initial != nil {
initial.File = nil
}
}
}
if des.Content != nil || (initial != nil && initial.Content != nil) {
// Check if anything else is set.
if dcl.AnySet(des.File) {
des.Content = nil
if initial != nil {
initial.Content = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile{}
cDes.File = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(des.File, initial.File, opts...)
if dcl.StringCanonicalize(des.Content, initial.Content) || dcl.IsZeroValue(des.Content) {
cDes.Content = initial.Content
} else {
cDes.Content = des.Content
}
if dcl.StringCanonicalize(des.Path, initial.Path) || dcl.IsZeroValue(des.Path) {
cDes.Path = initial.Path
} else {
cDes.Path = des.Path
}
if dcl.IsZeroValue(des.State) || (dcl.IsEmptyValueIndirect(des.State) && dcl.IsEmptyValueIndirect(initial.State)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.State = initial.State
} else {
cDes.State = des.State
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.File = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c, des.File, nw.File)
if dcl.StringCanonicalize(des.Content, nw.Content) {
nw.Content = des.Content
}
if dcl.StringCanonicalize(des.Path, nw.Path) {
nw.Path = des.Path
}
if dcl.StringCanonicalize(des.Permissions, nw.Permissions) {
nw.Permissions = des.Permissions
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.Remote != nil || (initial != nil && initial.Remote != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Gcs, des.LocalPath) {
des.Remote = nil
if initial != nil {
initial.Remote = nil
}
}
}
if des.Gcs != nil || (initial != nil && initial.Gcs != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.LocalPath) {
des.Gcs = nil
if initial != nil {
initial.Gcs = nil
}
}
}
if des.LocalPath != nil || (initial != nil && initial.LocalPath != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Remote, des.Gcs) {
des.LocalPath = nil
if initial != nil {
initial.LocalPath = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile{}
cDes.Remote = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(des.Remote, initial.Remote, opts...)
cDes.Gcs = canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(des.Gcs, initial.Gcs, opts...)
if dcl.StringCanonicalize(des.LocalPath, initial.LocalPath) || dcl.IsZeroValue(des.LocalPath) {
cDes.LocalPath = initial.LocalPath
} else {
cDes.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, initial.AllowInsecure) || dcl.IsZeroValue(des.AllowInsecure) {
cDes.AllowInsecure = initial.AllowInsecure
} else {
cDes.AllowInsecure = des.AllowInsecure
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.Remote = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c, des.Remote, nw.Remote)
nw.Gcs = canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c, des.Gcs, nw.Gcs)
if dcl.StringCanonicalize(des.LocalPath, nw.LocalPath) {
nw.LocalPath = des.LocalPath
}
if dcl.BoolCanonicalize(des.AllowInsecure, nw.AllowInsecure) {
nw.AllowInsecure = des.AllowInsecure
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote{}
if dcl.StringCanonicalize(des.Uri, initial.Uri) || dcl.IsZeroValue(des.Uri) {
cDes.Uri = initial.Uri
} else {
cDes.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, initial.Sha256Checksum) || dcl.IsZeroValue(des.Sha256Checksum) {
cDes.Sha256Checksum = initial.Sha256Checksum
} else {
cDes.Sha256Checksum = des.Sha256Checksum
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Uri, nw.Uri) {
nw.Uri = des.Uri
}
if dcl.StringCanonicalize(des.Sha256Checksum, nw.Sha256Checksum) {
nw.Sha256Checksum = des.Sha256Checksum
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(des, initial *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs, opts ...dcl.ApplyOption) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs{}
if dcl.StringCanonicalize(des.Bucket, initial.Bucket) || dcl.IsZeroValue(des.Bucket) {
cDes.Bucket = initial.Bucket
} else {
cDes.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, initial.Object) || dcl.IsZeroValue(des.Object) {
cDes.Object = initial.Object
} else {
cDes.Object = des.Object
}
if dcl.IsZeroValue(des.Generation) || (dcl.IsEmptyValueIndirect(des.Generation) && dcl.IsEmptyValueIndirect(initial.Generation)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Generation = initial.Generation
} else {
cDes.Generation = des.Generation
}
return cDes
}
func canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsSlice(des, initial []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs, opts ...dcl.ApplyOption) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c *Client, des, nw *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.Bucket, nw.Bucket) {
nw.Bucket = des.Bucket
}
if dcl.StringCanonicalize(des.Object, nw.Object) {
nw.Object = des.Object
}
return nw
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsSet(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsSlice(c *Client, des, nw []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentInstanceFilter(des, initial *OSPolicyAssignmentInstanceFilter, opts ...dcl.ApplyOption) *OSPolicyAssignmentInstanceFilter {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentInstanceFilter{}
if dcl.BoolCanonicalize(des.All, initial.All) || dcl.IsZeroValue(des.All) {
cDes.All = initial.All
} else {
cDes.All = des.All
}
cDes.InclusionLabels = canonicalizeOSPolicyAssignmentInstanceFilterInclusionLabelsSlice(des.InclusionLabels, initial.InclusionLabels, opts...)
cDes.ExclusionLabels = canonicalizeOSPolicyAssignmentInstanceFilterExclusionLabelsSlice(des.ExclusionLabels, initial.ExclusionLabels, opts...)
cDes.Inventories = canonicalizeOSPolicyAssignmentInstanceFilterInventoriesSlice(des.Inventories, initial.Inventories, opts...)
return cDes
}
func canonicalizeOSPolicyAssignmentInstanceFilterSlice(des, initial []OSPolicyAssignmentInstanceFilter, opts ...dcl.ApplyOption) []OSPolicyAssignmentInstanceFilter {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentInstanceFilter, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentInstanceFilter(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentInstanceFilter, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentInstanceFilter(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentInstanceFilter(c *Client, des, nw *OSPolicyAssignmentInstanceFilter) *OSPolicyAssignmentInstanceFilter {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentInstanceFilter while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.BoolCanonicalize(des.All, nw.All) {
nw.All = des.All
}
nw.InclusionLabels = canonicalizeNewOSPolicyAssignmentInstanceFilterInclusionLabelsSlice(c, des.InclusionLabels, nw.InclusionLabels)
nw.ExclusionLabels = canonicalizeNewOSPolicyAssignmentInstanceFilterExclusionLabelsSlice(c, des.ExclusionLabels, nw.ExclusionLabels)
nw.Inventories = canonicalizeNewOSPolicyAssignmentInstanceFilterInventoriesSlice(c, des.Inventories, nw.Inventories)
return nw
}
func canonicalizeNewOSPolicyAssignmentInstanceFilterSet(c *Client, des, nw []OSPolicyAssignmentInstanceFilter) []OSPolicyAssignmentInstanceFilter {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentInstanceFilter
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentInstanceFilterNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentInstanceFilter(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentInstanceFilterSlice(c *Client, des, nw []OSPolicyAssignmentInstanceFilter) []OSPolicyAssignmentInstanceFilter {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentInstanceFilter
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentInstanceFilter(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentInstanceFilterInclusionLabels(des, initial *OSPolicyAssignmentInstanceFilterInclusionLabels, opts ...dcl.ApplyOption) *OSPolicyAssignmentInstanceFilterInclusionLabels {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentInstanceFilterInclusionLabels{}
if dcl.IsZeroValue(des.Labels) || (dcl.IsEmptyValueIndirect(des.Labels) && dcl.IsEmptyValueIndirect(initial.Labels)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Labels = initial.Labels
} else {
cDes.Labels = des.Labels
}
return cDes
}
func canonicalizeOSPolicyAssignmentInstanceFilterInclusionLabelsSlice(des, initial []OSPolicyAssignmentInstanceFilterInclusionLabels, opts ...dcl.ApplyOption) []OSPolicyAssignmentInstanceFilterInclusionLabels {
if des == nil {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentInstanceFilterInclusionLabels, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentInstanceFilterInclusionLabels(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentInstanceFilterInclusionLabels, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentInstanceFilterInclusionLabels(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentInstanceFilterInclusionLabels(c *Client, des, nw *OSPolicyAssignmentInstanceFilterInclusionLabels) *OSPolicyAssignmentInstanceFilterInclusionLabels {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentInstanceFilterInclusionLabels while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
return nw
}
func canonicalizeNewOSPolicyAssignmentInstanceFilterInclusionLabelsSet(c *Client, des, nw []OSPolicyAssignmentInstanceFilterInclusionLabels) []OSPolicyAssignmentInstanceFilterInclusionLabels {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentInstanceFilterInclusionLabels
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentInstanceFilterInclusionLabelsNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentInstanceFilterInclusionLabels(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentInstanceFilterInclusionLabelsSlice(c *Client, des, nw []OSPolicyAssignmentInstanceFilterInclusionLabels) []OSPolicyAssignmentInstanceFilterInclusionLabels {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentInstanceFilterInclusionLabels
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentInstanceFilterInclusionLabels(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentInstanceFilterExclusionLabels(des, initial *OSPolicyAssignmentInstanceFilterExclusionLabels, opts ...dcl.ApplyOption) *OSPolicyAssignmentInstanceFilterExclusionLabels {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentInstanceFilterExclusionLabels{}
if dcl.IsZeroValue(des.Labels) || (dcl.IsEmptyValueIndirect(des.Labels) && dcl.IsEmptyValueIndirect(initial.Labels)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Labels = initial.Labels
} else {
cDes.Labels = des.Labels
}
return cDes
}
func canonicalizeOSPolicyAssignmentInstanceFilterExclusionLabelsSlice(des, initial []OSPolicyAssignmentInstanceFilterExclusionLabels, opts ...dcl.ApplyOption) []OSPolicyAssignmentInstanceFilterExclusionLabels {
if des == nil {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentInstanceFilterExclusionLabels, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentInstanceFilterExclusionLabels(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentInstanceFilterExclusionLabels, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentInstanceFilterExclusionLabels(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentInstanceFilterExclusionLabels(c *Client, des, nw *OSPolicyAssignmentInstanceFilterExclusionLabels) *OSPolicyAssignmentInstanceFilterExclusionLabels {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentInstanceFilterExclusionLabels while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
return nw
}
func canonicalizeNewOSPolicyAssignmentInstanceFilterExclusionLabelsSet(c *Client, des, nw []OSPolicyAssignmentInstanceFilterExclusionLabels) []OSPolicyAssignmentInstanceFilterExclusionLabels {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentInstanceFilterExclusionLabels
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentInstanceFilterExclusionLabelsNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentInstanceFilterExclusionLabels(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentInstanceFilterExclusionLabelsSlice(c *Client, des, nw []OSPolicyAssignmentInstanceFilterExclusionLabels) []OSPolicyAssignmentInstanceFilterExclusionLabels {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentInstanceFilterExclusionLabels
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentInstanceFilterExclusionLabels(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentInstanceFilterInventories(des, initial *OSPolicyAssignmentInstanceFilterInventories, opts ...dcl.ApplyOption) *OSPolicyAssignmentInstanceFilterInventories {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentInstanceFilterInventories{}
if dcl.StringCanonicalize(des.OSShortName, initial.OSShortName) || dcl.IsZeroValue(des.OSShortName) {
cDes.OSShortName = initial.OSShortName
} else {
cDes.OSShortName = des.OSShortName
}
if dcl.StringCanonicalize(des.OSVersion, initial.OSVersion) || dcl.IsZeroValue(des.OSVersion) {
cDes.OSVersion = initial.OSVersion
} else {
cDes.OSVersion = des.OSVersion
}
return cDes
}
func canonicalizeOSPolicyAssignmentInstanceFilterInventoriesSlice(des, initial []OSPolicyAssignmentInstanceFilterInventories, opts ...dcl.ApplyOption) []OSPolicyAssignmentInstanceFilterInventories {
if des == nil {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentInstanceFilterInventories, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentInstanceFilterInventories(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentInstanceFilterInventories, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentInstanceFilterInventories(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentInstanceFilterInventories(c *Client, des, nw *OSPolicyAssignmentInstanceFilterInventories) *OSPolicyAssignmentInstanceFilterInventories {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentInstanceFilterInventories while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
if dcl.StringCanonicalize(des.OSShortName, nw.OSShortName) {
nw.OSShortName = des.OSShortName
}
if dcl.StringCanonicalize(des.OSVersion, nw.OSVersion) {
nw.OSVersion = des.OSVersion
}
return nw
}
func canonicalizeNewOSPolicyAssignmentInstanceFilterInventoriesSet(c *Client, des, nw []OSPolicyAssignmentInstanceFilterInventories) []OSPolicyAssignmentInstanceFilterInventories {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentInstanceFilterInventories
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentInstanceFilterInventoriesNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentInstanceFilterInventories(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentInstanceFilterInventoriesSlice(c *Client, des, nw []OSPolicyAssignmentInstanceFilterInventories) []OSPolicyAssignmentInstanceFilterInventories {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentInstanceFilterInventories
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentInstanceFilterInventories(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentRollout(des, initial *OSPolicyAssignmentRollout, opts ...dcl.ApplyOption) *OSPolicyAssignmentRollout {
if des == nil {
return initial
}
if des.empty {
return des
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentRollout{}
cDes.DisruptionBudget = canonicalizeOSPolicyAssignmentRolloutDisruptionBudget(des.DisruptionBudget, initial.DisruptionBudget, opts...)
if canonicalizeOSPolicyAssignmentRolloutMinWaitDuration(des.MinWaitDuration, initial.MinWaitDuration) || dcl.IsZeroValue(des.MinWaitDuration) {
cDes.MinWaitDuration = initial.MinWaitDuration
} else {
cDes.MinWaitDuration = des.MinWaitDuration
}
return cDes
}
func canonicalizeOSPolicyAssignmentRolloutSlice(des, initial []OSPolicyAssignmentRollout, opts ...dcl.ApplyOption) []OSPolicyAssignmentRollout {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentRollout, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentRollout(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentRollout, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentRollout(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentRollout(c *Client, des, nw *OSPolicyAssignmentRollout) *OSPolicyAssignmentRollout {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentRollout while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
nw.DisruptionBudget = canonicalizeNewOSPolicyAssignmentRolloutDisruptionBudget(c, des.DisruptionBudget, nw.DisruptionBudget)
if canonicalizeOSPolicyAssignmentRolloutMinWaitDuration(des.MinWaitDuration, nw.MinWaitDuration) {
nw.MinWaitDuration = des.MinWaitDuration
}
return nw
}
func canonicalizeNewOSPolicyAssignmentRolloutSet(c *Client, des, nw []OSPolicyAssignmentRollout) []OSPolicyAssignmentRollout {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentRollout
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentRolloutNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentRollout(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentRolloutSlice(c *Client, des, nw []OSPolicyAssignmentRollout) []OSPolicyAssignmentRollout {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentRollout
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentRollout(c, &d, &n))
}
return items
}
func canonicalizeOSPolicyAssignmentRolloutDisruptionBudget(des, initial *OSPolicyAssignmentRolloutDisruptionBudget, opts ...dcl.ApplyOption) *OSPolicyAssignmentRolloutDisruptionBudget {
if des == nil {
return initial
}
if des.empty {
return des
}
if des.Fixed != nil || (initial != nil && initial.Fixed != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Percent) {
des.Fixed = nil
if initial != nil {
initial.Fixed = nil
}
}
}
if des.Percent != nil || (initial != nil && initial.Percent != nil) {
// Check if anything else is set.
if dcl.AnySet(des.Fixed) {
des.Percent = nil
if initial != nil {
initial.Percent = nil
}
}
}
if initial == nil {
return des
}
cDes := &OSPolicyAssignmentRolloutDisruptionBudget{}
if dcl.IsZeroValue(des.Fixed) || (dcl.IsEmptyValueIndirect(des.Fixed) && dcl.IsEmptyValueIndirect(initial.Fixed)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Fixed = initial.Fixed
} else {
cDes.Fixed = des.Fixed
}
if dcl.IsZeroValue(des.Percent) || (dcl.IsEmptyValueIndirect(des.Percent) && dcl.IsEmptyValueIndirect(initial.Percent)) {
// Desired and initial values are equivalent, so set canonical desired value to initial value.
cDes.Percent = initial.Percent
} else {
cDes.Percent = des.Percent
}
return cDes
}
func canonicalizeOSPolicyAssignmentRolloutDisruptionBudgetSlice(des, initial []OSPolicyAssignmentRolloutDisruptionBudget, opts ...dcl.ApplyOption) []OSPolicyAssignmentRolloutDisruptionBudget {
if dcl.IsEmptyValueIndirect(des) {
return initial
}
if len(des) != len(initial) {
items := make([]OSPolicyAssignmentRolloutDisruptionBudget, 0, len(des))
for _, d := range des {
cd := canonicalizeOSPolicyAssignmentRolloutDisruptionBudget(&d, nil, opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
items := make([]OSPolicyAssignmentRolloutDisruptionBudget, 0, len(des))
for i, d := range des {
cd := canonicalizeOSPolicyAssignmentRolloutDisruptionBudget(&d, &initial[i], opts...)
if cd != nil {
items = append(items, *cd)
}
}
return items
}
func canonicalizeNewOSPolicyAssignmentRolloutDisruptionBudget(c *Client, des, nw *OSPolicyAssignmentRolloutDisruptionBudget) *OSPolicyAssignmentRolloutDisruptionBudget {
if des == nil {
return nw
}
if nw == nil {
if dcl.IsEmptyValueIndirect(des) {
c.Config.Logger.Info("Found explicitly empty value for OSPolicyAssignmentRolloutDisruptionBudget while comparing non-nil desired to nil actual. Returning desired object.")
return des
}
return nil
}
return nw
}
func canonicalizeNewOSPolicyAssignmentRolloutDisruptionBudgetSet(c *Client, des, nw []OSPolicyAssignmentRolloutDisruptionBudget) []OSPolicyAssignmentRolloutDisruptionBudget {
if des == nil {
return nw
}
// Find the elements in des that are also in nw and canonicalize them. Remove matched elements from nw.
var items []OSPolicyAssignmentRolloutDisruptionBudget
for _, d := range des {
matchedIndex := -1
for i, n := range nw {
if diffs, _ := compareOSPolicyAssignmentRolloutDisruptionBudgetNewStyle(&d, &n, dcl.FieldName{}); len(diffs) == 0 {
matchedIndex = i
break
}
}
if matchedIndex != -1 {
items = append(items, *canonicalizeNewOSPolicyAssignmentRolloutDisruptionBudget(c, &d, &nw[matchedIndex]))
nw = append(nw[:matchedIndex], nw[matchedIndex+1:]...)
}
}
// Also include elements in nw that are not matched in des.
items = append(items, nw...)
return items
}
func canonicalizeNewOSPolicyAssignmentRolloutDisruptionBudgetSlice(c *Client, des, nw []OSPolicyAssignmentRolloutDisruptionBudget) []OSPolicyAssignmentRolloutDisruptionBudget {
if des == nil {
return nw
}
// Lengths are unequal. A diff will occur later, so we shouldn't canonicalize.
// Return the original array.
if len(des) != len(nw) {
return nw
}
var items []OSPolicyAssignmentRolloutDisruptionBudget
for i, d := range des {
n := nw[i]
items = append(items, *canonicalizeNewOSPolicyAssignmentRolloutDisruptionBudget(c, &d, &n))
}
return items
}
// The differ returns a list of diffs, along with a list of operations that should be taken
// to remedy them. Right now, it does not attempt to consolidate operations - if several
// fields can be fixed with a patch update, it will perform the patch several times.
// Diffs on some fields will be ignored if the `desired` state has an empty (nil)
// value. This empty value indicates that the user does not care about the state for
// the field. Empty fields on the actual object will cause diffs.
// TODO(magic-modules-eng): for efficiency in some resources, add batching.
func diffOSPolicyAssignment(c *Client, desired, actual *OSPolicyAssignment, opts ...dcl.ApplyOption) ([]*dcl.FieldDiff, error) {
if desired == nil || actual == nil {
return nil, fmt.Errorf("nil resource passed to diff - always a programming error: %#v, %#v", desired, actual)
}
c.Config.Logger.Infof("Diff function called with desired state: %v", desired)
c.Config.Logger.Infof("Diff function called with actual state: %v", actual)
var fn dcl.FieldName
var newDiffs []*dcl.FieldDiff
// New style diffs.
if ds, err := dcl.Diff(desired.Name, actual.Name, dcl.DiffInfo{OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("Name")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.Description, actual.Description, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Description")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.OSPolicies, actual.OSPolicies, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPolicies, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("OsPolicies")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.InstanceFilter, actual.InstanceFilter, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentInstanceFilterNewStyle, EmptyObject: EmptyOSPolicyAssignmentInstanceFilter, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("InstanceFilter")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.Rollout, actual.Rollout, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentRolloutNewStyle, EmptyObject: EmptyOSPolicyAssignmentRollout, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Rollout")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.RevisionId, actual.RevisionId, dcl.DiffInfo{OutputOnly: true, OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("RevisionId")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.RevisionCreateTime, actual.RevisionCreateTime, dcl.DiffInfo{OutputOnly: true, OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("RevisionCreateTime")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.Etag, actual.Etag, dcl.DiffInfo{OutputOnly: true, OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("Etag")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.RolloutState, actual.RolloutState, dcl.DiffInfo{OutputOnly: true, Type: "EnumType", OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("RolloutState")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.Baseline, actual.Baseline, dcl.DiffInfo{OutputOnly: true, OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("Baseline")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.Deleted, actual.Deleted, dcl.DiffInfo{OutputOnly: true, OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("Deleted")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.Reconciling, actual.Reconciling, dcl.DiffInfo{OutputOnly: true, OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("Reconciling")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.Uid, actual.Uid, dcl.DiffInfo{OutputOnly: true, OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("Uid")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.Project, actual.Project, dcl.DiffInfo{Type: "ReferenceType", OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("Project")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.Location, actual.Location, dcl.DiffInfo{OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("Location")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if ds, err := dcl.Diff(desired.SkipAwaitRollout, actual.SkipAwaitRollout, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("SkipAwaitRollout")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
newDiffs = append(newDiffs, ds...)
}
if len(newDiffs) > 0 {
c.Config.Logger.Infof("Diff function found diffs: %v", newDiffs)
}
return newDiffs, nil
}
func compareOSPolicyAssignmentOSPoliciesNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPolicies)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPolicies)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPolicies or *OSPolicyAssignmentOSPolicies", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPolicies)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPolicies)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPolicies", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Id, actual.Id, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Id")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Description, actual.Description, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Description")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Mode, actual.Mode, dcl.DiffInfo{Type: "EnumType", OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Mode")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.ResourceGroups, actual.ResourceGroups, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroups, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("ResourceGroups")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.AllowNoResourceGroupMatch, actual.AllowNoResourceGroupMatch, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("AllowNoResourceGroupMatch")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroups)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroups)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroups or *OSPolicyAssignmentOSPoliciesResourceGroups", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroups)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroups)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroups", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.InventoryFilters, actual.InventoryFilters, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("InventoryFilters")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Resources, actual.Resources, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResources, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Resources")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters or *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.OSShortName, actual.OSShortName, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("OsShortName")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.OSVersion, actual.OSVersion, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("OsVersion")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResources)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResources)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResources or *OSPolicyAssignmentOSPoliciesResourceGroupsResources", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResources)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResources)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResources", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Id, actual.Id, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Id")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Pkg, actual.Pkg, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Pkg")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Repository, actual.Repository, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Repository")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Exec, actual.Exec, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Exec")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.File, actual.File, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("File")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.DesiredState, actual.DesiredState, dcl.DiffInfo{Type: "EnumType", OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("DesiredState")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Apt, actual.Apt, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Apt")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Deb, actual.Deb, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Deb")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Yum, actual.Yum, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Yum")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Zypper, actual.Zypper, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Zypper")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Rpm, actual.Rpm, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Rpm")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Googet, actual.Googet, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Googet")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Msi, actual.Msi, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Msi")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Name, actual.Name, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Name")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Source, actual.Source, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Source")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.PullDeps, actual.PullDeps, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("PullDeps")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Remote, actual.Remote, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Remote")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Gcs, actual.Gcs, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Gcs")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.LocalPath, actual.LocalPath, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("LocalPath")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.AllowInsecure, actual.AllowInsecure, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("AllowInsecure")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Uri, actual.Uri, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Uri")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Sha256Checksum, actual.Sha256Checksum, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Sha256Checksum")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Bucket, actual.Bucket, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Bucket")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Object, actual.Object, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Object")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Generation, actual.Generation, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Generation")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Name, actual.Name, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Name")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Name, actual.Name, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Name")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Source, actual.Source, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Source")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.PullDeps, actual.PullDeps, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("PullDeps")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Remote, actual.Remote, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Remote")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Gcs, actual.Gcs, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Gcs")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.LocalPath, actual.LocalPath, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("LocalPath")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.AllowInsecure, actual.AllowInsecure, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("AllowInsecure")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Uri, actual.Uri, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Uri")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Sha256Checksum, actual.Sha256Checksum, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Sha256Checksum")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Bucket, actual.Bucket, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Bucket")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Object, actual.Object, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Object")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Generation, actual.Generation, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Generation")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Name, actual.Name, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Name")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Source, actual.Source, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Source")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Properties, actual.Properties, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Properties")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Remote, actual.Remote, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Remote")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Gcs, actual.Gcs, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Gcs")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.LocalPath, actual.LocalPath, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("LocalPath")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.AllowInsecure, actual.AllowInsecure, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("AllowInsecure")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Uri, actual.Uri, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Uri")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Sha256Checksum, actual.Sha256Checksum, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Sha256Checksum")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Bucket, actual.Bucket, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Bucket")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Object, actual.Object, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Object")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Generation, actual.Generation, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Generation")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Apt, actual.Apt, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Apt")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Yum, actual.Yum, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Yum")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Zypper, actual.Zypper, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Zypper")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Goo, actual.Goo, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Goo")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.ArchiveType, actual.ArchiveType, dcl.DiffInfo{Type: "EnumType", OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("ArchiveType")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Uri, actual.Uri, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Uri")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Distribution, actual.Distribution, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Distribution")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Components, actual.Components, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Components")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.GpgKey, actual.GpgKey, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("GpgKey")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Id, actual.Id, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Id")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.DisplayName, actual.DisplayName, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("DisplayName")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.BaseUrl, actual.BaseUrl, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("BaseUrl")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.GpgKeys, actual.GpgKeys, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("GpgKeys")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Id, actual.Id, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Id")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.DisplayName, actual.DisplayName, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("DisplayName")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.BaseUrl, actual.BaseUrl, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("BaseUrl")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.GpgKeys, actual.GpgKeys, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("GpgKeys")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Name, actual.Name, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Name")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Url, actual.Url, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Url")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Validate, actual.Validate, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Validate")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Enforce, actual.Enforce, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Enforce")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.File, actual.File, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("File")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Script, actual.Script, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Script")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Args, actual.Args, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Args")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Interpreter, actual.Interpreter, dcl.DiffInfo{Type: "EnumType", OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Interpreter")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.OutputFilePath, actual.OutputFilePath, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("OutputFilePath")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Remote, actual.Remote, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Remote")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Gcs, actual.Gcs, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Gcs")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.LocalPath, actual.LocalPath, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("LocalPath")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.AllowInsecure, actual.AllowInsecure, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("AllowInsecure")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Uri, actual.Uri, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Uri")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Sha256Checksum, actual.Sha256Checksum, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Sha256Checksum")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Bucket, actual.Bucket, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Bucket")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Object, actual.Object, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Object")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Generation, actual.Generation, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Generation")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.File, actual.File, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("File")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Script, actual.Script, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Script")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Args, actual.Args, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Args")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Interpreter, actual.Interpreter, dcl.DiffInfo{Type: "EnumType", OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Interpreter")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.OutputFilePath, actual.OutputFilePath, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("OutputFilePath")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Remote, actual.Remote, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Remote")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Gcs, actual.Gcs, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Gcs")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.LocalPath, actual.LocalPath, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("LocalPath")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.AllowInsecure, actual.AllowInsecure, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("AllowInsecure")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Uri, actual.Uri, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Uri")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Sha256Checksum, actual.Sha256Checksum, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Sha256Checksum")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Bucket, actual.Bucket, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Bucket")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Object, actual.Object, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Object")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Generation, actual.Generation, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Generation")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.File, actual.File, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("File")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Content, actual.Content, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Content")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Path, actual.Path, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Path")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.State, actual.State, dcl.DiffInfo{Type: "EnumType", OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("State")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Permissions, actual.Permissions, dcl.DiffInfo{OutputOnly: true, OperationSelector: dcl.RequiresRecreate()}, fn.AddNest("Permissions")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Remote, actual.Remote, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Remote")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Gcs, actual.Gcs, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsNewStyle, EmptyObject: EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Gcs")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.LocalPath, actual.LocalPath, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("LocalPath")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.AllowInsecure, actual.AllowInsecure, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("AllowInsecure")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Uri, actual.Uri, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Uri")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Sha256Checksum, actual.Sha256Checksum, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Sha256Checksum")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs or *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Bucket, actual.Bucket, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Bucket")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Object, actual.Object, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Object")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Generation, actual.Generation, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Generation")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentInstanceFilterNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentInstanceFilter)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentInstanceFilter)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentInstanceFilter or *OSPolicyAssignmentInstanceFilter", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentInstanceFilter)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentInstanceFilter)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentInstanceFilter", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.All, actual.All, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("All")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.InclusionLabels, actual.InclusionLabels, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentInstanceFilterInclusionLabelsNewStyle, EmptyObject: EmptyOSPolicyAssignmentInstanceFilterInclusionLabels, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("InclusionLabels")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.ExclusionLabels, actual.ExclusionLabels, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentInstanceFilterExclusionLabelsNewStyle, EmptyObject: EmptyOSPolicyAssignmentInstanceFilterExclusionLabels, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("ExclusionLabels")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Inventories, actual.Inventories, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentInstanceFilterInventoriesNewStyle, EmptyObject: EmptyOSPolicyAssignmentInstanceFilterInventories, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Inventories")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentInstanceFilterInclusionLabelsNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentInstanceFilterInclusionLabels)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentInstanceFilterInclusionLabels)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentInstanceFilterInclusionLabels or *OSPolicyAssignmentInstanceFilterInclusionLabels", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentInstanceFilterInclusionLabels)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentInstanceFilterInclusionLabels)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentInstanceFilterInclusionLabels", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Labels, actual.Labels, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Labels")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentInstanceFilterExclusionLabelsNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentInstanceFilterExclusionLabels)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentInstanceFilterExclusionLabels)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentInstanceFilterExclusionLabels or *OSPolicyAssignmentInstanceFilterExclusionLabels", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentInstanceFilterExclusionLabels)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentInstanceFilterExclusionLabels)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentInstanceFilterExclusionLabels", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Labels, actual.Labels, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Labels")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentInstanceFilterInventoriesNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentInstanceFilterInventories)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentInstanceFilterInventories)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentInstanceFilterInventories or *OSPolicyAssignmentInstanceFilterInventories", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentInstanceFilterInventories)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentInstanceFilterInventories)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentInstanceFilterInventories", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.OSShortName, actual.OSShortName, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("OsShortName")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.OSVersion, actual.OSVersion, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("OsVersion")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentRolloutNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentRollout)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentRollout)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentRollout or *OSPolicyAssignmentRollout", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentRollout)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentRollout)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentRollout", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.DisruptionBudget, actual.DisruptionBudget, dcl.DiffInfo{ObjectFunction: compareOSPolicyAssignmentRolloutDisruptionBudgetNewStyle, EmptyObject: EmptyOSPolicyAssignmentRolloutDisruptionBudget, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("DisruptionBudget")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.MinWaitDuration, actual.MinWaitDuration, dcl.DiffInfo{CustomDiff: canonicalizeOSPolicyAssignmentRolloutMinWaitDuration, OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("MinWaitDuration")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
func compareOSPolicyAssignmentRolloutDisruptionBudgetNewStyle(d, a interface{}, fn dcl.FieldName) ([]*dcl.FieldDiff, error) {
var diffs []*dcl.FieldDiff
desired, ok := d.(*OSPolicyAssignmentRolloutDisruptionBudget)
if !ok {
desiredNotPointer, ok := d.(OSPolicyAssignmentRolloutDisruptionBudget)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentRolloutDisruptionBudget or *OSPolicyAssignmentRolloutDisruptionBudget", d)
}
desired = &desiredNotPointer
}
actual, ok := a.(*OSPolicyAssignmentRolloutDisruptionBudget)
if !ok {
actualNotPointer, ok := a.(OSPolicyAssignmentRolloutDisruptionBudget)
if !ok {
return nil, fmt.Errorf("obj %v is not a OSPolicyAssignmentRolloutDisruptionBudget", a)
}
actual = &actualNotPointer
}
if ds, err := dcl.Diff(desired.Fixed, actual.Fixed, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Fixed")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
if ds, err := dcl.Diff(desired.Percent, actual.Percent, dcl.DiffInfo{OperationSelector: dcl.TriggersOperation("updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation")}, fn.AddNest("Percent")); len(ds) != 0 || err != nil {
if err != nil {
return nil, err
}
diffs = append(diffs, ds...)
}
return diffs, nil
}
// urlNormalized returns a copy of the resource struct with values normalized
// for URL substitutions. For instance, it converts long-form self-links to
// short-form so they can be substituted in.
func (r *OSPolicyAssignment) urlNormalized() *OSPolicyAssignment {
normalized := dcl.Copy(*r).(OSPolicyAssignment)
normalized.Name = dcl.SelfLinkToName(r.Name)
normalized.Description = dcl.SelfLinkToName(r.Description)
normalized.RevisionId = dcl.SelfLinkToName(r.RevisionId)
normalized.Etag = dcl.SelfLinkToName(r.Etag)
normalized.Uid = dcl.SelfLinkToName(r.Uid)
normalized.Project = dcl.SelfLinkToName(r.Project)
normalized.Location = dcl.SelfLinkToName(r.Location)
return &normalized
}
func (r *OSPolicyAssignment) updateURL(userBasePath, updateName string) (string, error) {
nr := r.urlNormalized()
if updateName == "UpdateOSPolicyAssignment" {
fields := map[string]interface{}{
"project": dcl.ValueOrEmptyString(nr.Project),
"location": dcl.ValueOrEmptyString(nr.Location),
"name": dcl.ValueOrEmptyString(nr.Name),
}
return dcl.URL("projects/{{project}}/locations/{{location}}/osPolicyAssignments/{{name}}", nr.basePath(), userBasePath, fields), nil
}
return "", fmt.Errorf("unknown update name: %s", updateName)
}
// marshal encodes the OSPolicyAssignment resource into JSON for a Create request, and
// performs transformations from the resource schema to the API schema if
// necessary.
func (r *OSPolicyAssignment) marshal(c *Client) ([]byte, error) {
m, err := expandOSPolicyAssignment(c, r)
if err != nil {
return nil, fmt.Errorf("error marshalling OSPolicyAssignment: %w", err)
}
dcl.MoveMapEntry(
m,
[]string{"skipAwaitRollout"},
[]string{},
)
return json.Marshal(m)
}
// unmarshalOSPolicyAssignment decodes JSON responses into the OSPolicyAssignment resource schema.
func unmarshalOSPolicyAssignment(b []byte, c *Client, res *OSPolicyAssignment) (*OSPolicyAssignment, error) {
var m map[string]interface{}
if err := json.Unmarshal(b, &m); err != nil {
return nil, err
}
return unmarshalMapOSPolicyAssignment(m, c, res)
}
func unmarshalMapOSPolicyAssignment(m map[string]interface{}, c *Client, res *OSPolicyAssignment) (*OSPolicyAssignment, error) {
flattened := flattenOSPolicyAssignment(c, m, res)
if flattened == nil {
return nil, fmt.Errorf("attempted to flatten empty json object")
}
return flattened, nil
}
// expandOSPolicyAssignment expands OSPolicyAssignment into a JSON request object.
func expandOSPolicyAssignment(c *Client, f *OSPolicyAssignment) (map[string]interface{}, error) {
m := make(map[string]interface{})
res := f
_ = res
if v, err := dcl.DeriveField("projects/%s/locations/%s/osPolicyAssignments/%s", f.Name, dcl.SelfLinkToName(f.Project), dcl.SelfLinkToName(f.Location), dcl.SelfLinkToName(f.Name)); err != nil {
return nil, fmt.Errorf("error expanding Name into name: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["name"] = v
}
if v := f.Description; dcl.ValueShouldBeSent(v) {
m["description"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesSlice(c, f.OSPolicies, res); err != nil {
return nil, fmt.Errorf("error expanding OSPolicies into osPolicies: %w", err)
} else if v != nil {
m["osPolicies"] = v
}
if v, err := expandOSPolicyAssignmentInstanceFilter(c, f.InstanceFilter, res); err != nil {
return nil, fmt.Errorf("error expanding InstanceFilter into instanceFilter: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["instanceFilter"] = v
}
if v, err := expandOSPolicyAssignmentRollout(c, f.Rollout, res); err != nil {
return nil, fmt.Errorf("error expanding Rollout into rollout: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["rollout"] = v
}
if v, err := dcl.EmptyValue(); err != nil {
return nil, fmt.Errorf("error expanding Project into project: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["project"] = v
}
if v, err := dcl.EmptyValue(); err != nil {
return nil, fmt.Errorf("error expanding Location into location: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["location"] = v
}
if v := f.SkipAwaitRollout; dcl.ValueShouldBeSent(v) {
m["skipAwaitRollout"] = v
}
return m, nil
}
// flattenOSPolicyAssignment flattens OSPolicyAssignment from a JSON request object into the
// OSPolicyAssignment type.
func flattenOSPolicyAssignment(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignment {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
if len(m) == 0 {
return nil
}
resultRes := &OSPolicyAssignment{}
resultRes.Name = dcl.FlattenString(m["name"])
resultRes.Description = dcl.FlattenString(m["description"])
resultRes.OSPolicies = flattenOSPolicyAssignmentOSPoliciesSlice(c, m["osPolicies"], res)
resultRes.InstanceFilter = flattenOSPolicyAssignmentInstanceFilter(c, m["instanceFilter"], res)
resultRes.Rollout = flattenOSPolicyAssignmentRollout(c, m["rollout"], res)
resultRes.RevisionId = dcl.FlattenString(m["revisionId"])
resultRes.RevisionCreateTime = dcl.FlattenString(m["revisionCreateTime"])
resultRes.Etag = dcl.FlattenString(m["etag"])
resultRes.RolloutState = flattenOSPolicyAssignmentRolloutStateEnum(m["rolloutState"])
resultRes.Baseline = dcl.FlattenBool(m["baseline"])
resultRes.Deleted = dcl.FlattenBool(m["deleted"])
resultRes.Reconciling = dcl.FlattenBool(m["reconciling"])
resultRes.Uid = dcl.FlattenString(m["uid"])
resultRes.Project = dcl.FlattenString(m["project"])
resultRes.Location = dcl.FlattenString(m["location"])
resultRes.SkipAwaitRollout = dcl.FlattenBool(m["skipAwaitRollout"])
return resultRes
}
// expandOSPolicyAssignmentOSPoliciesMap expands the contents of OSPolicyAssignmentOSPolicies into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesMap(c *Client, f map[string]OSPolicyAssignmentOSPolicies, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPolicies(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesSlice expands the contents of OSPolicyAssignmentOSPolicies into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesSlice(c *Client, f []OSPolicyAssignmentOSPolicies, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPolicies(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesMap flattens the contents of OSPolicyAssignmentOSPolicies from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPolicies {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPolicies{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPolicies{}
}
items := make(map[string]OSPolicyAssignmentOSPolicies)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPolicies(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesSlice flattens the contents of OSPolicyAssignmentOSPolicies from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPolicies {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPolicies{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPolicies{}
}
items := make([]OSPolicyAssignmentOSPolicies, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPolicies(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPolicies expands an instance of OSPolicyAssignmentOSPolicies into a JSON
// request object.
func expandOSPolicyAssignmentOSPolicies(c *Client, f *OSPolicyAssignmentOSPolicies, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Id; !dcl.IsEmptyValueIndirect(v) {
m["id"] = v
}
if v := f.Description; !dcl.IsEmptyValueIndirect(v) {
m["description"] = v
}
if v := f.Mode; !dcl.IsEmptyValueIndirect(v) {
m["mode"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsSlice(c, f.ResourceGroups, res); err != nil {
return nil, fmt.Errorf("error expanding ResourceGroups into resourceGroups: %w", err)
} else if v != nil {
m["resourceGroups"] = v
}
if v := f.AllowNoResourceGroupMatch; !dcl.IsEmptyValueIndirect(v) {
m["allowNoResourceGroupMatch"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPolicies flattens an instance of OSPolicyAssignmentOSPolicies from a JSON
// response object.
func flattenOSPolicyAssignmentOSPolicies(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPolicies {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPolicies{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPolicies
}
r.Id = dcl.FlattenString(m["id"])
r.Description = dcl.FlattenString(m["description"])
r.Mode = flattenOSPolicyAssignmentOSPoliciesModeEnum(m["mode"])
r.ResourceGroups = flattenOSPolicyAssignmentOSPoliciesResourceGroupsSlice(c, m["resourceGroups"], res)
r.AllowNoResourceGroupMatch = dcl.FlattenBool(m["allowNoResourceGroupMatch"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroups into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroups, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroups(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroups into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroups, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroups(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroups from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroups {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroups{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroups{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroups)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroups(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroups from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroups {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroups{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroups{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroups, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroups(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroups expands an instance of OSPolicyAssignmentOSPoliciesResourceGroups into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroups(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroups, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersSlice(c, f.InventoryFilters, res); err != nil {
return nil, fmt.Errorf("error expanding InventoryFilters into inventoryFilters: %w", err)
} else if v != nil {
m["inventoryFilters"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesSlice(c, f.Resources, res); err != nil {
return nil, fmt.Errorf("error expanding Resources into resources: %w", err)
} else if v != nil {
m["resources"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroups flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroups from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroups(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroups {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroups{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroups
}
r.InventoryFilters = flattenOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersSlice(c, m["inventoryFilters"], res)
r.Resources = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesSlice(c, m["resources"], res)
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
m := make(map[string]interface{})
if v := f.OSShortName; !dcl.IsEmptyValueIndirect(v) {
m["osShortName"] = v
}
if v := f.OSVersion; !dcl.IsEmptyValueIndirect(v) {
m["osVersion"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters
}
r.OSShortName = dcl.FlattenString(m["osShortName"])
r.OSVersion = dcl.FlattenString(m["osVersion"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResources into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResources, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResources(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResources into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResources, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResources(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResources from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResources {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResources{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResources{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResources)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResources(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResources from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResources {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResources{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResources{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResources, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResources(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResources expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResources into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResources(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResources, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Id; !dcl.IsEmptyValueIndirect(v) {
m["id"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c, f.Pkg, res); err != nil {
return nil, fmt.Errorf("error expanding Pkg into pkg: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["pkg"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c, f.Repository, res); err != nil {
return nil, fmt.Errorf("error expanding Repository into repository: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["repository"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c, f.Exec, res); err != nil {
return nil, fmt.Errorf("error expanding Exec into exec: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["exec"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c, f.File, res); err != nil {
return nil, fmt.Errorf("error expanding File into file: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["file"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResources flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResources from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResources(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResources {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResources{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResources
}
r.Id = dcl.FlattenString(m["id"])
r.Pkg = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c, m["pkg"], res)
r.Repository = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c, m["repository"], res)
r.Exec = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c, m["exec"], res)
r.File = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c, m["file"], res)
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.DesiredState; !dcl.IsEmptyValueIndirect(v) {
m["desiredState"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c, f.Apt, res); err != nil {
return nil, fmt.Errorf("error expanding Apt into apt: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["apt"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c, f.Deb, res); err != nil {
return nil, fmt.Errorf("error expanding Deb into deb: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["deb"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c, f.Yum, res); err != nil {
return nil, fmt.Errorf("error expanding Yum into yum: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["yum"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c, f.Zypper, res); err != nil {
return nil, fmt.Errorf("error expanding Zypper into zypper: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["zypper"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c, f.Rpm, res); err != nil {
return nil, fmt.Errorf("error expanding Rpm into rpm: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["rpm"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c, f.Googet, res); err != nil {
return nil, fmt.Errorf("error expanding Googet into googet: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["googet"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c, f.Msi, res); err != nil {
return nil, fmt.Errorf("error expanding Msi into msi: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["msi"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg
}
r.DesiredState = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum(m["desiredState"])
r.Apt = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c, m["apt"], res)
r.Deb = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c, m["deb"], res)
r.Yum = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c, m["yum"], res)
r.Zypper = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c, m["zypper"], res)
r.Rpm = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c, m["rpm"], res)
r.Googet = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c, m["googet"], res)
r.Msi = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c, m["msi"], res)
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Name; !dcl.IsEmptyValueIndirect(v) {
m["name"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt
}
r.Name = dcl.FlattenString(m["name"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c, f.Source, res); err != nil {
return nil, fmt.Errorf("error expanding Source into source: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["source"] = v
}
if v := f.PullDeps; !dcl.IsEmptyValueIndirect(v) {
m["pullDeps"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb
}
r.Source = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c, m["source"], res)
r.PullDeps = dcl.FlattenBool(m["pullDeps"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c, f.Remote, res); err != nil {
return nil, fmt.Errorf("error expanding Remote into remote: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["remote"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c, f.Gcs, res); err != nil {
return nil, fmt.Errorf("error expanding Gcs into gcs: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["gcs"] = v
}
if v := f.LocalPath; !dcl.IsEmptyValueIndirect(v) {
m["localPath"] = v
}
if v := f.AllowInsecure; !dcl.IsEmptyValueIndirect(v) {
m["allowInsecure"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource
}
r.Remote = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c, m["remote"], res)
r.Gcs = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c, m["gcs"], res)
r.LocalPath = dcl.FlattenString(m["localPath"])
r.AllowInsecure = dcl.FlattenBool(m["allowInsecure"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Uri; !dcl.IsEmptyValueIndirect(v) {
m["uri"] = v
}
if v := f.Sha256Checksum; !dcl.IsEmptyValueIndirect(v) {
m["sha256Checksum"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote
}
r.Uri = dcl.FlattenString(m["uri"])
r.Sha256Checksum = dcl.FlattenString(m["sha256Checksum"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Bucket; !dcl.IsEmptyValueIndirect(v) {
m["bucket"] = v
}
if v := f.Object; !dcl.IsEmptyValueIndirect(v) {
m["object"] = v
}
if v := f.Generation; !dcl.IsEmptyValueIndirect(v) {
m["generation"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs
}
r.Bucket = dcl.FlattenString(m["bucket"])
r.Object = dcl.FlattenString(m["object"])
r.Generation = dcl.FlattenInteger(m["generation"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Name; !dcl.IsEmptyValueIndirect(v) {
m["name"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum
}
r.Name = dcl.FlattenString(m["name"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Name; !dcl.IsEmptyValueIndirect(v) {
m["name"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper
}
r.Name = dcl.FlattenString(m["name"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c, f.Source, res); err != nil {
return nil, fmt.Errorf("error expanding Source into source: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["source"] = v
}
if v := f.PullDeps; !dcl.IsEmptyValueIndirect(v) {
m["pullDeps"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm
}
r.Source = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c, m["source"], res)
r.PullDeps = dcl.FlattenBool(m["pullDeps"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c, f.Remote, res); err != nil {
return nil, fmt.Errorf("error expanding Remote into remote: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["remote"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c, f.Gcs, res); err != nil {
return nil, fmt.Errorf("error expanding Gcs into gcs: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["gcs"] = v
}
if v := f.LocalPath; !dcl.IsEmptyValueIndirect(v) {
m["localPath"] = v
}
if v := f.AllowInsecure; !dcl.IsEmptyValueIndirect(v) {
m["allowInsecure"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource
}
r.Remote = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c, m["remote"], res)
r.Gcs = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c, m["gcs"], res)
r.LocalPath = dcl.FlattenString(m["localPath"])
r.AllowInsecure = dcl.FlattenBool(m["allowInsecure"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Uri; !dcl.IsEmptyValueIndirect(v) {
m["uri"] = v
}
if v := f.Sha256Checksum; !dcl.IsEmptyValueIndirect(v) {
m["sha256Checksum"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote
}
r.Uri = dcl.FlattenString(m["uri"])
r.Sha256Checksum = dcl.FlattenString(m["sha256Checksum"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Bucket; !dcl.IsEmptyValueIndirect(v) {
m["bucket"] = v
}
if v := f.Object; !dcl.IsEmptyValueIndirect(v) {
m["object"] = v
}
if v := f.Generation; !dcl.IsEmptyValueIndirect(v) {
m["generation"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs
}
r.Bucket = dcl.FlattenString(m["bucket"])
r.Object = dcl.FlattenString(m["object"])
r.Generation = dcl.FlattenInteger(m["generation"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Name; !dcl.IsEmptyValueIndirect(v) {
m["name"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget
}
r.Name = dcl.FlattenString(m["name"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c, f.Source, res); err != nil {
return nil, fmt.Errorf("error expanding Source into source: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["source"] = v
}
if v := f.Properties; v != nil {
m["properties"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi
}
r.Source = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c, m["source"], res)
r.Properties = dcl.FlattenStringSlice(m["properties"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c, f.Remote, res); err != nil {
return nil, fmt.Errorf("error expanding Remote into remote: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["remote"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c, f.Gcs, res); err != nil {
return nil, fmt.Errorf("error expanding Gcs into gcs: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["gcs"] = v
}
if v := f.LocalPath; !dcl.IsEmptyValueIndirect(v) {
m["localPath"] = v
}
if v := f.AllowInsecure; !dcl.IsEmptyValueIndirect(v) {
m["allowInsecure"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource
}
r.Remote = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c, m["remote"], res)
r.Gcs = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c, m["gcs"], res)
r.LocalPath = dcl.FlattenString(m["localPath"])
r.AllowInsecure = dcl.FlattenBool(m["allowInsecure"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Uri; !dcl.IsEmptyValueIndirect(v) {
m["uri"] = v
}
if v := f.Sha256Checksum; !dcl.IsEmptyValueIndirect(v) {
m["sha256Checksum"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote
}
r.Uri = dcl.FlattenString(m["uri"])
r.Sha256Checksum = dcl.FlattenString(m["sha256Checksum"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Bucket; !dcl.IsEmptyValueIndirect(v) {
m["bucket"] = v
}
if v := f.Object; !dcl.IsEmptyValueIndirect(v) {
m["object"] = v
}
if v := f.Generation; !dcl.IsEmptyValueIndirect(v) {
m["generation"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs
}
r.Bucket = dcl.FlattenString(m["bucket"])
r.Object = dcl.FlattenString(m["object"])
r.Generation = dcl.FlattenInteger(m["generation"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositorySlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositorySlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositorySlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositorySlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c, f.Apt, res); err != nil {
return nil, fmt.Errorf("error expanding Apt into apt: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["apt"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c, f.Yum, res); err != nil {
return nil, fmt.Errorf("error expanding Yum into yum: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["yum"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c, f.Zypper, res); err != nil {
return nil, fmt.Errorf("error expanding Zypper into zypper: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["zypper"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c, f.Goo, res); err != nil {
return nil, fmt.Errorf("error expanding Goo into goo: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["goo"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository
}
r.Apt = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c, m["apt"], res)
r.Yum = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c, m["yum"], res)
r.Zypper = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c, m["zypper"], res)
r.Goo = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c, m["goo"], res)
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.ArchiveType; !dcl.IsEmptyValueIndirect(v) {
m["archiveType"] = v
}
if v := f.Uri; !dcl.IsEmptyValueIndirect(v) {
m["uri"] = v
}
if v := f.Distribution; !dcl.IsEmptyValueIndirect(v) {
m["distribution"] = v
}
if v := f.Components; v != nil {
m["components"] = v
}
if v := f.GpgKey; !dcl.IsEmptyValueIndirect(v) {
m["gpgKey"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt
}
r.ArchiveType = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum(m["archiveType"])
r.Uri = dcl.FlattenString(m["uri"])
r.Distribution = dcl.FlattenString(m["distribution"])
r.Components = dcl.FlattenStringSlice(m["components"])
r.GpgKey = dcl.FlattenString(m["gpgKey"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Id; !dcl.IsEmptyValueIndirect(v) {
m["id"] = v
}
if v := f.DisplayName; !dcl.IsEmptyValueIndirect(v) {
m["displayName"] = v
}
if v := f.BaseUrl; !dcl.IsEmptyValueIndirect(v) {
m["baseUrl"] = v
}
if v := f.GpgKeys; v != nil {
m["gpgKeys"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum
}
r.Id = dcl.FlattenString(m["id"])
r.DisplayName = dcl.FlattenString(m["displayName"])
r.BaseUrl = dcl.FlattenString(m["baseUrl"])
r.GpgKeys = dcl.FlattenStringSlice(m["gpgKeys"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Id; !dcl.IsEmptyValueIndirect(v) {
m["id"] = v
}
if v := f.DisplayName; !dcl.IsEmptyValueIndirect(v) {
m["displayName"] = v
}
if v := f.BaseUrl; !dcl.IsEmptyValueIndirect(v) {
m["baseUrl"] = v
}
if v := f.GpgKeys; v != nil {
m["gpgKeys"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper
}
r.Id = dcl.FlattenString(m["id"])
r.DisplayName = dcl.FlattenString(m["displayName"])
r.BaseUrl = dcl.FlattenString(m["baseUrl"])
r.GpgKeys = dcl.FlattenStringSlice(m["gpgKeys"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Name; !dcl.IsEmptyValueIndirect(v) {
m["name"] = v
}
if v := f.Url; !dcl.IsEmptyValueIndirect(v) {
m["url"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo
}
r.Name = dcl.FlattenString(m["name"])
r.Url = dcl.FlattenString(m["url"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c, f.Validate, res); err != nil {
return nil, fmt.Errorf("error expanding Validate into validate: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["validate"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c, f.Enforce, res); err != nil {
return nil, fmt.Errorf("error expanding Enforce into enforce: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["enforce"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec
}
r.Validate = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c, m["validate"], res)
r.Enforce = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c, m["enforce"], res)
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c, f.File, res); err != nil {
return nil, fmt.Errorf("error expanding File into file: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["file"] = v
}
if v := f.Script; !dcl.IsEmptyValueIndirect(v) {
m["script"] = v
}
if v := f.Args; v != nil {
m["args"] = v
}
if v := f.Interpreter; !dcl.IsEmptyValueIndirect(v) {
m["interpreter"] = v
}
if v := f.OutputFilePath; !dcl.IsEmptyValueIndirect(v) {
m["outputFilePath"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate
}
r.File = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c, m["file"], res)
r.Script = dcl.FlattenString(m["script"])
r.Args = dcl.FlattenStringSlice(m["args"])
r.Interpreter = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum(m["interpreter"])
r.OutputFilePath = dcl.FlattenString(m["outputFilePath"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c, f.Remote, res); err != nil {
return nil, fmt.Errorf("error expanding Remote into remote: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["remote"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c, f.Gcs, res); err != nil {
return nil, fmt.Errorf("error expanding Gcs into gcs: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["gcs"] = v
}
if v := f.LocalPath; !dcl.IsEmptyValueIndirect(v) {
m["localPath"] = v
}
if v := f.AllowInsecure; !dcl.IsEmptyValueIndirect(v) {
m["allowInsecure"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile
}
r.Remote = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c, m["remote"], res)
r.Gcs = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c, m["gcs"], res)
r.LocalPath = dcl.FlattenString(m["localPath"])
r.AllowInsecure = dcl.FlattenBool(m["allowInsecure"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Uri; !dcl.IsEmptyValueIndirect(v) {
m["uri"] = v
}
if v := f.Sha256Checksum; !dcl.IsEmptyValueIndirect(v) {
m["sha256Checksum"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote
}
r.Uri = dcl.FlattenString(m["uri"])
r.Sha256Checksum = dcl.FlattenString(m["sha256Checksum"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Bucket; !dcl.IsEmptyValueIndirect(v) {
m["bucket"] = v
}
if v := f.Object; !dcl.IsEmptyValueIndirect(v) {
m["object"] = v
}
if v := f.Generation; !dcl.IsEmptyValueIndirect(v) {
m["generation"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs
}
r.Bucket = dcl.FlattenString(m["bucket"])
r.Object = dcl.FlattenString(m["object"])
r.Generation = dcl.FlattenInteger(m["generation"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c, f.File, res); err != nil {
return nil, fmt.Errorf("error expanding File into file: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["file"] = v
}
if v := f.Script; !dcl.IsEmptyValueIndirect(v) {
m["script"] = v
}
if v := f.Args; v != nil {
m["args"] = v
}
if v := f.Interpreter; !dcl.IsEmptyValueIndirect(v) {
m["interpreter"] = v
}
if v := f.OutputFilePath; !dcl.IsEmptyValueIndirect(v) {
m["outputFilePath"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce
}
r.File = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c, m["file"], res)
r.Script = dcl.FlattenString(m["script"])
r.Args = dcl.FlattenStringSlice(m["args"])
r.Interpreter = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum(m["interpreter"])
r.OutputFilePath = dcl.FlattenString(m["outputFilePath"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c, f.Remote, res); err != nil {
return nil, fmt.Errorf("error expanding Remote into remote: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["remote"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c, f.Gcs, res); err != nil {
return nil, fmt.Errorf("error expanding Gcs into gcs: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["gcs"] = v
}
if v := f.LocalPath; !dcl.IsEmptyValueIndirect(v) {
m["localPath"] = v
}
if v := f.AllowInsecure; !dcl.IsEmptyValueIndirect(v) {
m["allowInsecure"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile
}
r.Remote = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c, m["remote"], res)
r.Gcs = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c, m["gcs"], res)
r.LocalPath = dcl.FlattenString(m["localPath"])
r.AllowInsecure = dcl.FlattenBool(m["allowInsecure"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Uri; !dcl.IsEmptyValueIndirect(v) {
m["uri"] = v
}
if v := f.Sha256Checksum; !dcl.IsEmptyValueIndirect(v) {
m["sha256Checksum"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote
}
r.Uri = dcl.FlattenString(m["uri"])
r.Sha256Checksum = dcl.FlattenString(m["sha256Checksum"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Bucket; !dcl.IsEmptyValueIndirect(v) {
m["bucket"] = v
}
if v := f.Object; !dcl.IsEmptyValueIndirect(v) {
m["object"] = v
}
if v := f.Generation; !dcl.IsEmptyValueIndirect(v) {
m["generation"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs
}
r.Bucket = dcl.FlattenString(m["bucket"])
r.Object = dcl.FlattenString(m["object"])
r.Generation = dcl.FlattenInteger(m["generation"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c, f.File, res); err != nil {
return nil, fmt.Errorf("error expanding File into file: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["file"] = v
}
if v := f.Content; !dcl.IsEmptyValueIndirect(v) {
m["content"] = v
}
if v := f.Path; !dcl.IsEmptyValueIndirect(v) {
m["path"] = v
}
if v := f.State; !dcl.IsEmptyValueIndirect(v) {
m["state"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile
}
r.File = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c, m["file"], res)
r.Content = dcl.FlattenString(m["content"])
r.Path = dcl.FlattenString(m["path"])
r.State = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum(m["state"])
r.Permissions = dcl.FlattenString(m["permissions"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c, f.Remote, res); err != nil {
return nil, fmt.Errorf("error expanding Remote into remote: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["remote"] = v
}
if v, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c, f.Gcs, res); err != nil {
return nil, fmt.Errorf("error expanding Gcs into gcs: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["gcs"] = v
}
if v := f.LocalPath; !dcl.IsEmptyValueIndirect(v) {
m["localPath"] = v
}
if v := f.AllowInsecure; !dcl.IsEmptyValueIndirect(v) {
m["allowInsecure"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile
}
r.Remote = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c, m["remote"], res)
r.Gcs = flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c, m["gcs"], res)
r.LocalPath = dcl.FlattenString(m["localPath"])
r.AllowInsecure = dcl.FlattenBool(m["allowInsecure"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Uri; !dcl.IsEmptyValueIndirect(v) {
m["uri"] = v
}
if v := f.Sha256Checksum; !dcl.IsEmptyValueIndirect(v) {
m["sha256Checksum"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote
}
r.Uri = dcl.FlattenString(m["uri"])
r.Sha256Checksum = dcl.FlattenString(m["sha256Checksum"])
return r
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsMap expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsMap(c *Client, f map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsSlice expands the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsSlice(c *Client, f []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs expands an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs into a JSON
// request object.
func expandOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c *Client, f *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Bucket; !dcl.IsEmptyValueIndirect(v) {
m["bucket"] = v
}
if v := f.Object; !dcl.IsEmptyValueIndirect(v) {
m["object"] = v
}
if v := f.Generation; !dcl.IsEmptyValueIndirect(v) {
m["generation"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs flattens an instance of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs
}
r.Bucket = dcl.FlattenString(m["bucket"])
r.Object = dcl.FlattenString(m["object"])
r.Generation = dcl.FlattenInteger(m["generation"])
return r
}
// expandOSPolicyAssignmentInstanceFilterMap expands the contents of OSPolicyAssignmentInstanceFilter into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilterMap(c *Client, f map[string]OSPolicyAssignmentInstanceFilter, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentInstanceFilter(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentInstanceFilterSlice expands the contents of OSPolicyAssignmentInstanceFilter into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilterSlice(c *Client, f []OSPolicyAssignmentInstanceFilter, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentInstanceFilter(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentInstanceFilterMap flattens the contents of OSPolicyAssignmentInstanceFilter from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilterMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentInstanceFilter {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentInstanceFilter{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentInstanceFilter{}
}
items := make(map[string]OSPolicyAssignmentInstanceFilter)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentInstanceFilter(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentInstanceFilterSlice flattens the contents of OSPolicyAssignmentInstanceFilter from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilterSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentInstanceFilter {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentInstanceFilter{}
}
if len(a) == 0 {
return []OSPolicyAssignmentInstanceFilter{}
}
items := make([]OSPolicyAssignmentInstanceFilter, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentInstanceFilter(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentInstanceFilter expands an instance of OSPolicyAssignmentInstanceFilter into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilter(c *Client, f *OSPolicyAssignmentInstanceFilter, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.All; v != nil {
m["all"] = v
}
if v, err := expandOSPolicyAssignmentInstanceFilterInclusionLabelsSlice(c, f.InclusionLabels, res); err != nil {
return nil, fmt.Errorf("error expanding InclusionLabels into inclusionLabels: %w", err)
} else if v != nil {
m["inclusionLabels"] = v
}
if v, err := expandOSPolicyAssignmentInstanceFilterExclusionLabelsSlice(c, f.ExclusionLabels, res); err != nil {
return nil, fmt.Errorf("error expanding ExclusionLabels into exclusionLabels: %w", err)
} else if v != nil {
m["exclusionLabels"] = v
}
if v, err := expandOSPolicyAssignmentInstanceFilterInventoriesSlice(c, f.Inventories, res); err != nil {
return nil, fmt.Errorf("error expanding Inventories into inventories: %w", err)
} else if v != nil {
m["inventories"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentInstanceFilter flattens an instance of OSPolicyAssignmentInstanceFilter from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilter(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentInstanceFilter {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentInstanceFilter{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentInstanceFilter
}
r.All = dcl.FlattenBool(m["all"])
r.InclusionLabels = flattenOSPolicyAssignmentInstanceFilterInclusionLabelsSlice(c, m["inclusionLabels"], res)
r.ExclusionLabels = flattenOSPolicyAssignmentInstanceFilterExclusionLabelsSlice(c, m["exclusionLabels"], res)
r.Inventories = flattenOSPolicyAssignmentInstanceFilterInventoriesSlice(c, m["inventories"], res)
return r
}
// expandOSPolicyAssignmentInstanceFilterInclusionLabelsMap expands the contents of OSPolicyAssignmentInstanceFilterInclusionLabels into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilterInclusionLabelsMap(c *Client, f map[string]OSPolicyAssignmentInstanceFilterInclusionLabels, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentInstanceFilterInclusionLabels(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentInstanceFilterInclusionLabelsSlice expands the contents of OSPolicyAssignmentInstanceFilterInclusionLabels into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilterInclusionLabelsSlice(c *Client, f []OSPolicyAssignmentInstanceFilterInclusionLabels, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentInstanceFilterInclusionLabels(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentInstanceFilterInclusionLabelsMap flattens the contents of OSPolicyAssignmentInstanceFilterInclusionLabels from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilterInclusionLabelsMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentInstanceFilterInclusionLabels {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentInstanceFilterInclusionLabels{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentInstanceFilterInclusionLabels{}
}
items := make(map[string]OSPolicyAssignmentInstanceFilterInclusionLabels)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentInstanceFilterInclusionLabels(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentInstanceFilterInclusionLabelsSlice flattens the contents of OSPolicyAssignmentInstanceFilterInclusionLabels from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilterInclusionLabelsSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentInstanceFilterInclusionLabels {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentInstanceFilterInclusionLabels{}
}
if len(a) == 0 {
return []OSPolicyAssignmentInstanceFilterInclusionLabels{}
}
items := make([]OSPolicyAssignmentInstanceFilterInclusionLabels, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentInstanceFilterInclusionLabels(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentInstanceFilterInclusionLabels expands an instance of OSPolicyAssignmentInstanceFilterInclusionLabels into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilterInclusionLabels(c *Client, f *OSPolicyAssignmentInstanceFilterInclusionLabels, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Labels; !dcl.IsEmptyValueIndirect(v) {
m["labels"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentInstanceFilterInclusionLabels flattens an instance of OSPolicyAssignmentInstanceFilterInclusionLabels from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilterInclusionLabels(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentInstanceFilterInclusionLabels {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentInstanceFilterInclusionLabels{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentInstanceFilterInclusionLabels
}
r.Labels = dcl.FlattenKeyValuePairs(m["labels"])
return r
}
// expandOSPolicyAssignmentInstanceFilterExclusionLabelsMap expands the contents of OSPolicyAssignmentInstanceFilterExclusionLabels into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilterExclusionLabelsMap(c *Client, f map[string]OSPolicyAssignmentInstanceFilterExclusionLabels, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentInstanceFilterExclusionLabels(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentInstanceFilterExclusionLabelsSlice expands the contents of OSPolicyAssignmentInstanceFilterExclusionLabels into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilterExclusionLabelsSlice(c *Client, f []OSPolicyAssignmentInstanceFilterExclusionLabels, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentInstanceFilterExclusionLabels(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentInstanceFilterExclusionLabelsMap flattens the contents of OSPolicyAssignmentInstanceFilterExclusionLabels from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilterExclusionLabelsMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentInstanceFilterExclusionLabels {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentInstanceFilterExclusionLabels{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentInstanceFilterExclusionLabels{}
}
items := make(map[string]OSPolicyAssignmentInstanceFilterExclusionLabels)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentInstanceFilterExclusionLabels(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentInstanceFilterExclusionLabelsSlice flattens the contents of OSPolicyAssignmentInstanceFilterExclusionLabels from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilterExclusionLabelsSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentInstanceFilterExclusionLabels {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentInstanceFilterExclusionLabels{}
}
if len(a) == 0 {
return []OSPolicyAssignmentInstanceFilterExclusionLabels{}
}
items := make([]OSPolicyAssignmentInstanceFilterExclusionLabels, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentInstanceFilterExclusionLabels(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentInstanceFilterExclusionLabels expands an instance of OSPolicyAssignmentInstanceFilterExclusionLabels into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilterExclusionLabels(c *Client, f *OSPolicyAssignmentInstanceFilterExclusionLabels, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Labels; !dcl.IsEmptyValueIndirect(v) {
m["labels"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentInstanceFilterExclusionLabels flattens an instance of OSPolicyAssignmentInstanceFilterExclusionLabels from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilterExclusionLabels(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentInstanceFilterExclusionLabels {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentInstanceFilterExclusionLabels{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentInstanceFilterExclusionLabels
}
r.Labels = dcl.FlattenKeyValuePairs(m["labels"])
return r
}
// expandOSPolicyAssignmentInstanceFilterInventoriesMap expands the contents of OSPolicyAssignmentInstanceFilterInventories into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilterInventoriesMap(c *Client, f map[string]OSPolicyAssignmentInstanceFilterInventories, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentInstanceFilterInventories(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentInstanceFilterInventoriesSlice expands the contents of OSPolicyAssignmentInstanceFilterInventories into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilterInventoriesSlice(c *Client, f []OSPolicyAssignmentInstanceFilterInventories, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentInstanceFilterInventories(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentInstanceFilterInventoriesMap flattens the contents of OSPolicyAssignmentInstanceFilterInventories from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilterInventoriesMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentInstanceFilterInventories {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentInstanceFilterInventories{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentInstanceFilterInventories{}
}
items := make(map[string]OSPolicyAssignmentInstanceFilterInventories)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentInstanceFilterInventories(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentInstanceFilterInventoriesSlice flattens the contents of OSPolicyAssignmentInstanceFilterInventories from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilterInventoriesSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentInstanceFilterInventories {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentInstanceFilterInventories{}
}
if len(a) == 0 {
return []OSPolicyAssignmentInstanceFilterInventories{}
}
items := make([]OSPolicyAssignmentInstanceFilterInventories, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentInstanceFilterInventories(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentInstanceFilterInventories expands an instance of OSPolicyAssignmentInstanceFilterInventories into a JSON
// request object.
func expandOSPolicyAssignmentInstanceFilterInventories(c *Client, f *OSPolicyAssignmentInstanceFilterInventories, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
m := make(map[string]interface{})
if v := f.OSShortName; !dcl.IsEmptyValueIndirect(v) {
m["osShortName"] = v
}
if v := f.OSVersion; !dcl.IsEmptyValueIndirect(v) {
m["osVersion"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentInstanceFilterInventories flattens an instance of OSPolicyAssignmentInstanceFilterInventories from a JSON
// response object.
func flattenOSPolicyAssignmentInstanceFilterInventories(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentInstanceFilterInventories {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentInstanceFilterInventories{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentInstanceFilterInventories
}
r.OSShortName = dcl.FlattenString(m["osShortName"])
r.OSVersion = dcl.FlattenString(m["osVersion"])
return r
}
// expandOSPolicyAssignmentRolloutMap expands the contents of OSPolicyAssignmentRollout into a JSON
// request object.
func expandOSPolicyAssignmentRolloutMap(c *Client, f map[string]OSPolicyAssignmentRollout, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentRollout(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentRolloutSlice expands the contents of OSPolicyAssignmentRollout into a JSON
// request object.
func expandOSPolicyAssignmentRolloutSlice(c *Client, f []OSPolicyAssignmentRollout, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentRollout(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentRolloutMap flattens the contents of OSPolicyAssignmentRollout from a JSON
// response object.
func flattenOSPolicyAssignmentRolloutMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentRollout {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentRollout{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentRollout{}
}
items := make(map[string]OSPolicyAssignmentRollout)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentRollout(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentRolloutSlice flattens the contents of OSPolicyAssignmentRollout from a JSON
// response object.
func flattenOSPolicyAssignmentRolloutSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentRollout {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentRollout{}
}
if len(a) == 0 {
return []OSPolicyAssignmentRollout{}
}
items := make([]OSPolicyAssignmentRollout, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentRollout(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentRollout expands an instance of OSPolicyAssignmentRollout into a JSON
// request object.
func expandOSPolicyAssignmentRollout(c *Client, f *OSPolicyAssignmentRollout, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v, err := expandOSPolicyAssignmentRolloutDisruptionBudget(c, f.DisruptionBudget, res); err != nil {
return nil, fmt.Errorf("error expanding DisruptionBudget into disruptionBudget: %w", err)
} else if !dcl.IsEmptyValueIndirect(v) {
m["disruptionBudget"] = v
}
if v := f.MinWaitDuration; !dcl.IsEmptyValueIndirect(v) {
m["minWaitDuration"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentRollout flattens an instance of OSPolicyAssignmentRollout from a JSON
// response object.
func flattenOSPolicyAssignmentRollout(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentRollout {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentRollout{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentRollout
}
r.DisruptionBudget = flattenOSPolicyAssignmentRolloutDisruptionBudget(c, m["disruptionBudget"], res)
r.MinWaitDuration = dcl.FlattenString(m["minWaitDuration"])
return r
}
// expandOSPolicyAssignmentRolloutDisruptionBudgetMap expands the contents of OSPolicyAssignmentRolloutDisruptionBudget into a JSON
// request object.
func expandOSPolicyAssignmentRolloutDisruptionBudgetMap(c *Client, f map[string]OSPolicyAssignmentRolloutDisruptionBudget, res *OSPolicyAssignment) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandOSPolicyAssignmentRolloutDisruptionBudget(c, &item, res)
if err != nil {
return nil, err
}
if i != nil {
items[k] = i
}
}
return items, nil
}
// expandOSPolicyAssignmentRolloutDisruptionBudgetSlice expands the contents of OSPolicyAssignmentRolloutDisruptionBudget into a JSON
// request object.
func expandOSPolicyAssignmentRolloutDisruptionBudgetSlice(c *Client, f []OSPolicyAssignmentRolloutDisruptionBudget, res *OSPolicyAssignment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandOSPolicyAssignmentRolloutDisruptionBudget(c, &item, res)
if err != nil {
return nil, err
}
items = append(items, i)
}
return items, nil
}
// flattenOSPolicyAssignmentRolloutDisruptionBudgetMap flattens the contents of OSPolicyAssignmentRolloutDisruptionBudget from a JSON
// response object.
func flattenOSPolicyAssignmentRolloutDisruptionBudgetMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentRolloutDisruptionBudget {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentRolloutDisruptionBudget{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentRolloutDisruptionBudget{}
}
items := make(map[string]OSPolicyAssignmentRolloutDisruptionBudget)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentRolloutDisruptionBudget(c, item.(map[string]interface{}), res)
}
return items
}
// flattenOSPolicyAssignmentRolloutDisruptionBudgetSlice flattens the contents of OSPolicyAssignmentRolloutDisruptionBudget from a JSON
// response object.
func flattenOSPolicyAssignmentRolloutDisruptionBudgetSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentRolloutDisruptionBudget {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentRolloutDisruptionBudget{}
}
if len(a) == 0 {
return []OSPolicyAssignmentRolloutDisruptionBudget{}
}
items := make([]OSPolicyAssignmentRolloutDisruptionBudget, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentRolloutDisruptionBudget(c, item.(map[string]interface{}), res))
}
return items
}
// expandOSPolicyAssignmentRolloutDisruptionBudget expands an instance of OSPolicyAssignmentRolloutDisruptionBudget into a JSON
// request object.
func expandOSPolicyAssignmentRolloutDisruptionBudget(c *Client, f *OSPolicyAssignmentRolloutDisruptionBudget, res *OSPolicyAssignment) (map[string]interface{}, error) {
if dcl.IsEmptyValueIndirect(f) {
return nil, nil
}
m := make(map[string]interface{})
if v := f.Fixed; !dcl.IsEmptyValueIndirect(v) {
m["fixed"] = v
}
if v := f.Percent; !dcl.IsEmptyValueIndirect(v) {
m["percent"] = v
}
return m, nil
}
// flattenOSPolicyAssignmentRolloutDisruptionBudget flattens an instance of OSPolicyAssignmentRolloutDisruptionBudget from a JSON
// response object.
func flattenOSPolicyAssignmentRolloutDisruptionBudget(c *Client, i interface{}, res *OSPolicyAssignment) *OSPolicyAssignmentRolloutDisruptionBudget {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &OSPolicyAssignmentRolloutDisruptionBudget{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyOSPolicyAssignmentRolloutDisruptionBudget
}
r.Fixed = dcl.FlattenInteger(m["fixed"])
r.Percent = dcl.FlattenInteger(m["percent"])
return r
}
// flattenOSPolicyAssignmentOSPoliciesModeEnumMap flattens the contents of OSPolicyAssignmentOSPoliciesModeEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesModeEnumMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesModeEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesModeEnum{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesModeEnum{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesModeEnum)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesModeEnum(item.(interface{}))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesModeEnumSlice flattens the contents of OSPolicyAssignmentOSPoliciesModeEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesModeEnumSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesModeEnum {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesModeEnum{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesModeEnum{}
}
items := make([]OSPolicyAssignmentOSPoliciesModeEnum, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesModeEnum(item.(interface{})))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesModeEnum asserts that an interface is a string, and returns a
// pointer to a *OSPolicyAssignmentOSPoliciesModeEnum with the same value as that string.
func flattenOSPolicyAssignmentOSPoliciesModeEnum(i interface{}) *OSPolicyAssignmentOSPoliciesModeEnum {
s, ok := i.(string)
if !ok {
return nil
}
return OSPolicyAssignmentOSPoliciesModeEnumRef(s)
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnumMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnumMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum(item.(interface{}))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnumSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnumSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum(item.(interface{})))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum asserts that an interface is a string, and returns a
// pointer to a *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum with the same value as that string.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum(i interface{}) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum {
s, ok := i.(string)
if !ok {
return nil
}
return OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnumRef(s)
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnumMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnumMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum(item.(interface{}))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnumSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnumSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum(item.(interface{})))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum asserts that an interface is a string, and returns a
// pointer to a *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum with the same value as that string.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum(i interface{}) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum {
s, ok := i.(string)
if !ok {
return nil
}
return OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnumRef(s)
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnumMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnumMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum(item.(interface{}))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnumSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnumSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum(item.(interface{})))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum asserts that an interface is a string, and returns a
// pointer to a *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum with the same value as that string.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum(i interface{}) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum {
s, ok := i.(string)
if !ok {
return nil
}
return OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnumRef(s)
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnumMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnumMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum(item.(interface{}))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnumSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnumSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum(item.(interface{})))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum asserts that an interface is a string, and returns a
// pointer to a *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum with the same value as that string.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum(i interface{}) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum {
s, ok := i.(string)
if !ok {
return nil
}
return OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnumRef(s)
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnumMap flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnumMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum{}
}
items := make(map[string]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum(item.(interface{}))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnumSlice flattens the contents of OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum from a JSON
// response object.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnumSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum{}
}
if len(a) == 0 {
return []OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum{}
}
items := make([]OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum(item.(interface{})))
}
return items
}
// flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum asserts that an interface is a string, and returns a
// pointer to a *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum with the same value as that string.
func flattenOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum(i interface{}) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum {
s, ok := i.(string)
if !ok {
return nil
}
return OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnumRef(s)
}
// flattenOSPolicyAssignmentRolloutStateEnumMap flattens the contents of OSPolicyAssignmentRolloutStateEnum from a JSON
// response object.
func flattenOSPolicyAssignmentRolloutStateEnumMap(c *Client, i interface{}, res *OSPolicyAssignment) map[string]OSPolicyAssignmentRolloutStateEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]OSPolicyAssignmentRolloutStateEnum{}
}
if len(a) == 0 {
return map[string]OSPolicyAssignmentRolloutStateEnum{}
}
items := make(map[string]OSPolicyAssignmentRolloutStateEnum)
for k, item := range a {
items[k] = *flattenOSPolicyAssignmentRolloutStateEnum(item.(interface{}))
}
return items
}
// flattenOSPolicyAssignmentRolloutStateEnumSlice flattens the contents of OSPolicyAssignmentRolloutStateEnum from a JSON
// response object.
func flattenOSPolicyAssignmentRolloutStateEnumSlice(c *Client, i interface{}, res *OSPolicyAssignment) []OSPolicyAssignmentRolloutStateEnum {
a, ok := i.([]interface{})
if !ok {
return []OSPolicyAssignmentRolloutStateEnum{}
}
if len(a) == 0 {
return []OSPolicyAssignmentRolloutStateEnum{}
}
items := make([]OSPolicyAssignmentRolloutStateEnum, 0, len(a))
for _, item := range a {
items = append(items, *flattenOSPolicyAssignmentRolloutStateEnum(item.(interface{})))
}
return items
}
// flattenOSPolicyAssignmentRolloutStateEnum asserts that an interface is a string, and returns a
// pointer to a *OSPolicyAssignmentRolloutStateEnum with the same value as that string.
func flattenOSPolicyAssignmentRolloutStateEnum(i interface{}) *OSPolicyAssignmentRolloutStateEnum {
s, ok := i.(string)
if !ok {
return nil
}
return OSPolicyAssignmentRolloutStateEnumRef(s)
}
// This function returns a matcher that checks whether a serialized resource matches this resource
// in its parameters (as defined by the fields in a Get, which definitionally define resource
// identity). This is useful in extracting the element from a List call.
func (r *OSPolicyAssignment) matcher(c *Client) func([]byte) bool {
return func(b []byte) bool {
cr, err := unmarshalOSPolicyAssignment(b, c, r)
if err != nil {
c.Config.Logger.Warning("failed to unmarshal provided resource in matcher.")
return false
}
nr := r.urlNormalized()
ncr := cr.urlNormalized()
c.Config.Logger.Infof("looking for %v\nin %v", nr, ncr)
if nr.Project == nil && ncr.Project == nil {
c.Config.Logger.Info("Both Project fields null - considering equal.")
} else if nr.Project == nil || ncr.Project == nil {
c.Config.Logger.Info("Only one Project field is null - considering unequal.")
return false
} else if *nr.Project != *ncr.Project {
return false
}
if nr.Location == nil && ncr.Location == nil {
c.Config.Logger.Info("Both Location fields null - considering equal.")
} else if nr.Location == nil || ncr.Location == nil {
c.Config.Logger.Info("Only one Location field is null - considering unequal.")
return false
} else if *nr.Location != *ncr.Location {
return false
}
if nr.Name == nil && ncr.Name == nil {
c.Config.Logger.Info("Both Name fields null - considering equal.")
} else if nr.Name == nil || ncr.Name == nil {
c.Config.Logger.Info("Only one Name field is null - considering unequal.")
return false
} else if *nr.Name != *ncr.Name {
return false
}
return true
}
}
type oSPolicyAssignmentDiff struct {
// The diff should include one or the other of RequiresRecreate or UpdateOp.
RequiresRecreate bool
UpdateOp oSPolicyAssignmentApiOperation
FieldName string // used for error logging
}
func convertFieldDiffsToOSPolicyAssignmentDiffs(config *dcl.Config, fds []*dcl.FieldDiff, opts []dcl.ApplyOption) ([]oSPolicyAssignmentDiff, error) {
opNamesToFieldDiffs := make(map[string][]*dcl.FieldDiff)
// Map each operation name to the field diffs associated with it.
for _, fd := range fds {
for _, ro := range fd.ResultingOperation {
if fieldDiffs, ok := opNamesToFieldDiffs[ro]; ok {
fieldDiffs = append(fieldDiffs, fd)
opNamesToFieldDiffs[ro] = fieldDiffs
} else {
config.Logger.Infof("%s required due to diff: %v", ro, fd)
opNamesToFieldDiffs[ro] = []*dcl.FieldDiff{fd}
}
}
}
var diffs []oSPolicyAssignmentDiff
// For each operation name, create a oSPolicyAssignmentDiff which contains the operation.
for opName, fieldDiffs := range opNamesToFieldDiffs {
// Use the first field diff's field name for logging required recreate error.
diff := oSPolicyAssignmentDiff{FieldName: fieldDiffs[0].FieldName}
if opName == "Recreate" {
diff.RequiresRecreate = true
} else {
apiOp, err := convertOpNameToOSPolicyAssignmentApiOperation(opName, fieldDiffs, opts...)
if err != nil {
return diffs, err
}
diff.UpdateOp = apiOp
}
diffs = append(diffs, diff)
}
return diffs, nil
}
func convertOpNameToOSPolicyAssignmentApiOperation(opName string, fieldDiffs []*dcl.FieldDiff, opts ...dcl.ApplyOption) (oSPolicyAssignmentApiOperation, error) {
switch opName {
case "updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation":
return &updateOSPolicyAssignmentUpdateOSPolicyAssignmentOperation{FieldDiffs: fieldDiffs}, nil
default:
return nil, fmt.Errorf("no such operation with name: %v", opName)
}
}
func extractOSPolicyAssignmentFields(r *OSPolicyAssignment) error {
vInstanceFilter := r.InstanceFilter
if vInstanceFilter == nil {
// note: explicitly not the empty object.
vInstanceFilter = &OSPolicyAssignmentInstanceFilter{}
}
if err := extractOSPolicyAssignmentInstanceFilterFields(r, vInstanceFilter); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vInstanceFilter) {
r.InstanceFilter = vInstanceFilter
}
vRollout := r.Rollout
if vRollout == nil {
// note: explicitly not the empty object.
vRollout = &OSPolicyAssignmentRollout{}
}
if err := extractOSPolicyAssignmentRolloutFields(r, vRollout); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRollout) {
r.Rollout = vRollout
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPolicies) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroups) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResources) error {
vPkg := o.Pkg
if vPkg == nil {
// note: explicitly not the empty object.
vPkg = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgFields(r, vPkg); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vPkg) {
o.Pkg = vPkg
}
vRepository := o.Repository
if vRepository == nil {
// note: explicitly not the empty object.
vRepository = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryFields(r, vRepository); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRepository) {
o.Repository = vRepository
}
vExec := o.Exec
if vExec == nil {
// note: explicitly not the empty object.
vExec = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecFields(r, vExec); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vExec) {
o.Exec = vExec
}
vFile := o.File
if vFile == nil {
// note: explicitly not the empty object.
vFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFields(r, vFile); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vFile) {
o.File = vFile
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) error {
vApt := o.Apt
if vApt == nil {
// note: explicitly not the empty object.
vApt = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptFields(r, vApt); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vApt) {
o.Apt = vApt
}
vDeb := o.Deb
if vDeb == nil {
// note: explicitly not the empty object.
vDeb = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebFields(r, vDeb); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vDeb) {
o.Deb = vDeb
}
vYum := o.Yum
if vYum == nil {
// note: explicitly not the empty object.
vYum = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumFields(r, vYum); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vYum) {
o.Yum = vYum
}
vZypper := o.Zypper
if vZypper == nil {
// note: explicitly not the empty object.
vZypper = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperFields(r, vZypper); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vZypper) {
o.Zypper = vZypper
}
vRpm := o.Rpm
if vRpm == nil {
// note: explicitly not the empty object.
vRpm = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmFields(r, vRpm); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRpm) {
o.Rpm = vRpm
}
vGooget := o.Googet
if vGooget == nil {
// note: explicitly not the empty object.
vGooget = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetFields(r, vGooget); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGooget) {
o.Googet = vGooget
}
vMsi := o.Msi
if vMsi == nil {
// note: explicitly not the empty object.
vMsi = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiFields(r, vMsi); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vMsi) {
o.Msi = vMsi
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) error {
vSource := o.Source
if vSource == nil {
// note: explicitly not the empty object.
vSource = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceFields(r, vSource); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vSource) {
o.Source = vSource
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) error {
vSource := o.Source
if vSource == nil {
// note: explicitly not the empty object.
vSource = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceFields(r, vSource); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vSource) {
o.Source = vSource
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) error {
vSource := o.Source
if vSource == nil {
// note: explicitly not the empty object.
vSource = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceFields(r, vSource); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vSource) {
o.Source = vSource
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) error {
vApt := o.Apt
if vApt == nil {
// note: explicitly not the empty object.
vApt = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptFields(r, vApt); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vApt) {
o.Apt = vApt
}
vYum := o.Yum
if vYum == nil {
// note: explicitly not the empty object.
vYum = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumFields(r, vYum); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vYum) {
o.Yum = vYum
}
vZypper := o.Zypper
if vZypper == nil {
// note: explicitly not the empty object.
vZypper = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperFields(r, vZypper); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vZypper) {
o.Zypper = vZypper
}
vGoo := o.Goo
if vGoo == nil {
// note: explicitly not the empty object.
vGoo = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooFields(r, vGoo); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGoo) {
o.Goo = vGoo
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) error {
vValidate := o.Validate
if vValidate == nil {
// note: explicitly not the empty object.
vValidate = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFields(r, vValidate); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vValidate) {
o.Validate = vValidate
}
vEnforce := o.Enforce
if vEnforce == nil {
// note: explicitly not the empty object.
vEnforce = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFields(r, vEnforce); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vEnforce) {
o.Enforce = vEnforce
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) error {
vFile := o.File
if vFile == nil {
// note: explicitly not the empty object.
vFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileFields(r, vFile); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vFile) {
o.File = vFile
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) error {
vFile := o.File
if vFile == nil {
// note: explicitly not the empty object.
vFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileFields(r, vFile); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vFile) {
o.File = vFile
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) error {
vFile := o.File
if vFile == nil {
// note: explicitly not the empty object.
vFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileFields(r, vFile); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vFile) {
o.File = vFile
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) error {
return nil
}
func extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) error {
return nil
}
func extractOSPolicyAssignmentInstanceFilterFields(r *OSPolicyAssignment, o *OSPolicyAssignmentInstanceFilter) error {
return nil
}
func extractOSPolicyAssignmentInstanceFilterInclusionLabelsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentInstanceFilterInclusionLabels) error {
return nil
}
func extractOSPolicyAssignmentInstanceFilterExclusionLabelsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentInstanceFilterExclusionLabels) error {
return nil
}
func extractOSPolicyAssignmentInstanceFilterInventoriesFields(r *OSPolicyAssignment, o *OSPolicyAssignmentInstanceFilterInventories) error {
return nil
}
func extractOSPolicyAssignmentRolloutFields(r *OSPolicyAssignment, o *OSPolicyAssignmentRollout) error {
vDisruptionBudget := o.DisruptionBudget
if vDisruptionBudget == nil {
// note: explicitly not the empty object.
vDisruptionBudget = &OSPolicyAssignmentRolloutDisruptionBudget{}
}
if err := extractOSPolicyAssignmentRolloutDisruptionBudgetFields(r, vDisruptionBudget); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vDisruptionBudget) {
o.DisruptionBudget = vDisruptionBudget
}
return nil
}
func extractOSPolicyAssignmentRolloutDisruptionBudgetFields(r *OSPolicyAssignment, o *OSPolicyAssignmentRolloutDisruptionBudget) error {
return nil
}
func postReadExtractOSPolicyAssignmentFields(r *OSPolicyAssignment) error {
vInstanceFilter := r.InstanceFilter
if vInstanceFilter == nil {
// note: explicitly not the empty object.
vInstanceFilter = &OSPolicyAssignmentInstanceFilter{}
}
if err := postReadExtractOSPolicyAssignmentInstanceFilterFields(r, vInstanceFilter); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vInstanceFilter) {
r.InstanceFilter = vInstanceFilter
}
vRollout := r.Rollout
if vRollout == nil {
// note: explicitly not the empty object.
vRollout = &OSPolicyAssignmentRollout{}
}
if err := postReadExtractOSPolicyAssignmentRolloutFields(r, vRollout); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRollout) {
r.Rollout = vRollout
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPolicies) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroups) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFiltersFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResources) error {
vPkg := o.Pkg
if vPkg == nil {
// note: explicitly not the empty object.
vPkg = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgFields(r, vPkg); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vPkg) {
o.Pkg = vPkg
}
vRepository := o.Repository
if vRepository == nil {
// note: explicitly not the empty object.
vRepository = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryFields(r, vRepository); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRepository) {
o.Repository = vRepository
}
vExec := o.Exec
if vExec == nil {
// note: explicitly not the empty object.
vExec = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecFields(r, vExec); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vExec) {
o.Exec = vExec
}
vFile := o.File
if vFile == nil {
// note: explicitly not the empty object.
vFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFields(r, vFile); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vFile) {
o.File = vFile
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) error {
vApt := o.Apt
if vApt == nil {
// note: explicitly not the empty object.
vApt = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptFields(r, vApt); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vApt) {
o.Apt = vApt
}
vDeb := o.Deb
if vDeb == nil {
// note: explicitly not the empty object.
vDeb = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebFields(r, vDeb); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vDeb) {
o.Deb = vDeb
}
vYum := o.Yum
if vYum == nil {
// note: explicitly not the empty object.
vYum = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumFields(r, vYum); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vYum) {
o.Yum = vYum
}
vZypper := o.Zypper
if vZypper == nil {
// note: explicitly not the empty object.
vZypper = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperFields(r, vZypper); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vZypper) {
o.Zypper = vZypper
}
vRpm := o.Rpm
if vRpm == nil {
// note: explicitly not the empty object.
vRpm = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmFields(r, vRpm); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRpm) {
o.Rpm = vRpm
}
vGooget := o.Googet
if vGooget == nil {
// note: explicitly not the empty object.
vGooget = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetFields(r, vGooget); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGooget) {
o.Googet = vGooget
}
vMsi := o.Msi
if vMsi == nil {
// note: explicitly not the empty object.
vMsi = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiFields(r, vMsi); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vMsi) {
o.Msi = vMsi
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgAptFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) error {
vSource := o.Source
if vSource == nil {
// note: explicitly not the empty object.
vSource = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceFields(r, vSource); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vSource) {
o.Source = vSource
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYumFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypperFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) error {
vSource := o.Source
if vSource == nil {
// note: explicitly not the empty object.
vSource = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceFields(r, vSource); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vSource) {
o.Source = vSource
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGoogetFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) error {
vSource := o.Source
if vSource == nil {
// note: explicitly not the empty object.
vSource = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceFields(r, vSource); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vSource) {
o.Source = vSource
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) error {
vApt := o.Apt
if vApt == nil {
// note: explicitly not the empty object.
vApt = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptFields(r, vApt); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vApt) {
o.Apt = vApt
}
vYum := o.Yum
if vYum == nil {
// note: explicitly not the empty object.
vYum = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumFields(r, vYum); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vYum) {
o.Yum = vYum
}
vZypper := o.Zypper
if vZypper == nil {
// note: explicitly not the empty object.
vZypper = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperFields(r, vZypper); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vZypper) {
o.Zypper = vZypper
}
vGoo := o.Goo
if vGoo == nil {
// note: explicitly not the empty object.
vGoo = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooFields(r, vGoo); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGoo) {
o.Goo = vGoo
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYumFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypperFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGooFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) error {
vValidate := o.Validate
if vValidate == nil {
// note: explicitly not the empty object.
vValidate = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFields(r, vValidate); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vValidate) {
o.Validate = vValidate
}
vEnforce := o.Enforce
if vEnforce == nil {
// note: explicitly not the empty object.
vEnforce = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFields(r, vEnforce); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vEnforce) {
o.Enforce = vEnforce
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) error {
vFile := o.File
if vFile == nil {
// note: explicitly not the empty object.
vFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileFields(r, vFile); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vFile) {
o.File = vFile
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) error {
vFile := o.File
if vFile == nil {
// note: explicitly not the empty object.
vFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileFields(r, vFile); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vFile) {
o.File = vFile
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) error {
vFile := o.File
if vFile == nil {
// note: explicitly not the empty object.
vFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileFields(r, vFile); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vFile) {
o.File = vFile
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) error {
vRemote := o.Remote
if vRemote == nil {
// note: explicitly not the empty object.
vRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteFields(r, vRemote); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vRemote) {
o.Remote = vRemote
}
vGcs := o.Gcs
if vGcs == nil {
// note: explicitly not the empty object.
vGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs{}
}
if err := extractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsFields(r, vGcs); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vGcs) {
o.Gcs = vGcs
}
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemoteFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) error {
return nil
}
func postReadExtractOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) error {
return nil
}
func postReadExtractOSPolicyAssignmentInstanceFilterFields(r *OSPolicyAssignment, o *OSPolicyAssignmentInstanceFilter) error {
return nil
}
func postReadExtractOSPolicyAssignmentInstanceFilterInclusionLabelsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentInstanceFilterInclusionLabels) error {
return nil
}
func postReadExtractOSPolicyAssignmentInstanceFilterExclusionLabelsFields(r *OSPolicyAssignment, o *OSPolicyAssignmentInstanceFilterExclusionLabels) error {
return nil
}
func postReadExtractOSPolicyAssignmentInstanceFilterInventoriesFields(r *OSPolicyAssignment, o *OSPolicyAssignmentInstanceFilterInventories) error {
return nil
}
func postReadExtractOSPolicyAssignmentRolloutFields(r *OSPolicyAssignment, o *OSPolicyAssignmentRollout) error {
vDisruptionBudget := o.DisruptionBudget
if vDisruptionBudget == nil {
// note: explicitly not the empty object.
vDisruptionBudget = &OSPolicyAssignmentRolloutDisruptionBudget{}
}
if err := extractOSPolicyAssignmentRolloutDisruptionBudgetFields(r, vDisruptionBudget); err != nil {
return err
}
if !dcl.IsEmptyValueIndirect(vDisruptionBudget) {
o.DisruptionBudget = vDisruptionBudget
}
return nil
}
func postReadExtractOSPolicyAssignmentRolloutDisruptionBudgetFields(r *OSPolicyAssignment, o *OSPolicyAssignmentRolloutDisruptionBudget) error {
return nil
}
|
package dcp
// Given an array of integers, find the first missing positive integer in linear time and constant space. In other words, find the lowest positive integer that does not exist in the array. The array can contain duplicates and negative numbers as well.
// For example, the input [3, 4, -1, 1] should give 2. The input [1, 2, 0] should give 3.
// You can modify the input array in-place.
//from https://stackoverflow.com/a/51346319
func firstMissingPositiveInteger(arr []int) int {
//function output is bound between 1 and len(arr)+1
abs := func(n int) int {
if n < 0 {
n = -n
}
return n
}
end := len(arr)
//sort negative values to the end of the array
//end becomes the lenght of the positive side of the array
for i := 0; i < end; i++ {
if arr[i] < 1 {
arr[end-1], arr[i] = arr[i], arr[end-1]
end--
i--
}
}
//iterate from 0 to end
//flag the index of numbers that are smaller or equal to end as present using the negative sign
for i := 0; i < end; i++ {
val := abs(arr[i])
if val <= end {
//use abs to avoid unflagging already flagged index
arr[val-1] = -abs(arr[val-1])
}
}
//iterate from 0 to end again
//if a position contains a positive number that indicates the index+1 of that position isn't present in the array
for i := 0; i < end; i++ {
if arr[i] > 0 {
return i + 1
}
}
//in case there are no positive numbers from 0 to end, it indicates all numbers between 1 and end are present in the array, the answer will be end+1
return end + 1
}
func mapFirstMissingPositiveInteger(arr []int) int {
max := len(arr) + 1
found := make(map[int]bool, max)
for _, v := range arr {
if v > 0 && v < max {
found[v] = true
}
}
for i := 1; i < max; i++ {
if !found[i] {
return i
}
}
return max
}
|
package rest
import (
"errors"
"net/http"
jwt "github.com/dgrijalva/jwt-go"
r "github.com/jinmukeji/jiujiantang-services/pkg/rest"
jwtmiddleware "github.com/jinmukeji/jiujiantang-services/pkg/rest/jwt"
"github.com/kataras/iris/v12"
"github.com/kataras/iris/v12/context"
)
// NewApp 创建一个实现了 http.Handler 接口的应用程序
func NewApp(base string, jwtSignInKey string) http.Handler {
app := iris.New().
Configure(iris.WithRemoteAddrHeader("X-Forwarded-For"))
// 配置自定义日志中间件
app.Logger().Install(log)
app.UseGlobal(r.CidMiddleware, r.LogMiddleware)
app.OnErrorCode(iris.StatusNotFound, r.NotFound)
app.OnErrorCode(iris.StatusInternalServerError, r.InternalServerError)
// jwt配置
jwtHandler := jwtmiddleware.New(jwtmiddleware.Config{
// 这个方法将验证jwt的token
ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) {
return []byte(jwtSignInKey), nil
},
SigningMethod: jwt.SigningMethodHS256,
ErrorHandler: onError,
Expiration: true,
JwtSignInKey: jwtSignInKey,
})
// 设置路由
h := newV2Handler(jwtHandler)
v2API := app.Party("/" + base)
v2API.Post("/users/signup", jwtHandler.Serve, h.parseJWTToken, h.UserSignUp)
v2API.Get("/owner/{owner_id:int}/organizations/users", setDataArrayFormat, jwtHandler.Serve, h.parseJWTToken, h.OwnerGetOrganizationUsersByOwnerID)
v2API.Get("/configuration/local_notification", h.GetLocalNotifications)
v2API.Post("/client/auth", h.ClientAuth)
v2API.Get("/version", h.GetVersion)
v2API.Get("/tips", h.GetTips)
v2API.Post("/feedback", jwtHandler.Serve, h.parseJWTToken, h.SubmitFeedback)
v2API.Post("/users/signin", jwtHandler.Serve, h.parseJWTToken, h.UserSignIn)
v2API.Post("/users/signout", jwtHandler.Serve, h.parseJWTToken, h.SignOut)
v2API.Get("/owner/users/{user_id:int}/profile", jwtHandler.Serve, h.parseJWTToken, h.GetUserProfile)
v2API.Put("/owner/users/{user_id:int}/profile", jwtHandler.Serve, h.parseJWTToken, h.ModifyUserProfile)
v2API.Get("/owner/users/{user_id:int}/preferences", jwtHandler.Serve, h.parseJWTToken, h.OwnerGetUserPreferences)
v2API.Post("/owner/users/signup", jwtHandler.Serve, h.parseJWTToken, h.OwnerSignUp)
v2API.Post("/owner/organizations/{organization_id:int}/users", setDataArrayFormat, jwtHandler.Serve, h.parseJWTToken, jwtHandler.Serve, h.parseJWTToken, h.OwnerAddOrganizationUsers)
v2API.Get("/owner/organizations/{organization_id:int}/users", setDataArrayFormat, jwtHandler.Serve, h.parseJWTToken, h.OwnerGetOrganizationUsers)
v2API.Post("/owner/organizations/{organization_id:int}/users/delete", jwtHandler.Serve, h.parseJWTToken, h.OwnerDeleteOrganizationUsers)
v2API.Post("/owner/organizations/{organization_id:int}/subscription", jwtHandler.Serve, h.parseJWTToken, h.GetOrganizationSubscription)
v2API.Post("/owner/measurements", jwtHandler.Serve, h.parseJWTToken, h.setClientIP, h.SubmitMeasurementData)
v2API.Get("/owner/measurements", setDataArrayFormat, jwtHandler.Serve, h.parseJWTToken, h.SearchHistory)
v2API.Put("/owner/measurements/{record_id:int}/remark", jwtHandler.Serve, h.parseJWTToken, h.SubmitRemark)
v2API.Post("/owner/measurements/{record_id:int}/analyze", jwtHandler.Serve, h.parseJWTToken, h.GetAnalyzeResult)
v2API.Get("/owner/measurements/{record_id:int}/analyze", jwtHandler.Serve, h.parseJWTToken, h.GetAnalyzeReport)
v2API.Post("/res/getUrl", h.GetJMResBaseURL)
v2API.Get("/owner/organizations", setDataArrayFormat, jwtHandler.Serve, h.parseJWTToken, h.OwnerGetOrganizations)
v2API.Get("/owner/measurements/{record_id:int}/token", jwtHandler.Serve, h.parseJWTToken, h.GetRecordToken)
v2API.Get("/owner/measurements/token/{token:string}/analyze", h.GetAnalyzeReportByToken)
v2API.Post("/owner/notification", jwtHandler.Serve, h.parseJWTToken, h.ReadPushNotification)
v2API.Get("/owner/notification", setDataArrayFormat, jwtHandler.Serve, h.parseJWTToken, h.GetPushNotifications)
v2API.Get("/bluetooth_name_prefix", jwtHandler.Serve, h.parseJWTToken, h.GetBluetoothNamePrefixes)
v2API.Post("/activation_code", jwtHandler.Serve, h.parseJWTToken, h.GetActivationCodeInfo)
v2API.Post("/owner/user/{user_id}/activation_code", jwtHandler.Serve, h.parseJWTToken, h.UseSubscriptionActivationCode)
v2API.Get("/user/{user_id:int}/subscription", jwtHandler.Serve, h.parseJWTToken, h.GetUserSubscriptions)
v2API.Get("/user/{user_id:int}/token", jwtHandler.Serve, h.parseJWTToken, h.GetLatestToken)
v2API.Post("/user/measurements/{user_id:int}/delete", jwtHandler.Serve, h.parseJWTToken, h.DeleteRecords)
v2API.Post("/owner/{owner_id:int}/users/sign_up", jwtHandler.Serve, h.parseJWTToken, h.OwnerUserSignUp)
v2API.Post("/owner/{owner_id:int}/users/delete", jwtHandler.Serve, h.parseJWTToken, h.OwnerDeleteUsers)
v2API.Post("/bind/{user_id:int}/old_user", jwtHandler.Serve, h.parseJWTToken, h.BindOldUser)
v2API.Post("/owner/measurements/{record_id:int}/v2/analyze", jwtHandler.Serve, h.parseJWTToken, h.GetV2AnalyzeResult)
v2API.Get("/owner/measurements/token/{token:string}/v2/analyze", h.GetV2AnalyzeReportByToken)
v2API.Get("/owner/measurements/{record_id:int}/v2/analyze", jwtHandler.Serve, h.parseJWTToken, h.GetV2AnalyzeReportByRecordID)
// 周报
v2API.Post("/owner/{user_id:int}/measurements/v2/weekly_report", jwtHandler.Serve, h.parseJWTToken, h.GetWeeklyReport)
// 月报
v2API.Post("/owner/{user_id:int}/measurements/v2/monthly_report", jwtHandler.Serve, h.parseJWTToken, h.GetMonthlyReport)
// 周趋势
v2API.Get("/owner/{user_id:int}/week_measurements", setDataArrayFormat, jwtHandler.Serve, h.parseJWTToken, h.SearchWeekHistory)
// 月趋势
v2API.Get("/owner/{user_id:int}/month_measurements", setDataArrayFormat, jwtHandler.Serve, h.parseJWTToken, h.SearchMonthHistory)
if err := app.Build(); err != nil {
log.Fatal(err)
}
return app
}
// parseJWTToken 解析JWT Token
func (h *v2Handler) parseJWTToken(ctx iris.Context) {
userToken := h.jwtMiddleware.Get(ctx)
var clientID, zone, customizedCode, name string
if claims, ok := userToken.Claims.(jwt.MapClaims); ok && userToken.Valid {
clientID = claims["client_id"].(string)
zone = claims["zone"].(string)
customizedCode = claims["customized_code"].(string)
name = claims["name"].(string)
}
ctx.Values().Set(ClientIDKey, clientID)
ctx.Values().Set(ClientZoneKey, zone)
ctx.Values().Set(ClientNameKey, name)
ctx.Values().Set(ClientCustomizedCodeKey, customizedCode)
ctx.Next()
}
// setClientIP 在context中设置Client IP
func (h *v2Handler) setClientIP(ctx iris.Context) {
ctx.Values().Set(RemoteClientIPKey, ctx.RemoteAddr())
ctx.Next()
}
// onErrorDataArrayFormat 错误data数组格式
const onErrorDataArrayFormat = "onErrorDataArrayFormat"
func setDataArrayFormat(ctx iris.Context) {
ctx.Values().Set(onErrorDataArrayFormat, true)
ctx.Next()
}
func onError(ctx context.Context, err string) {
isArray := ctx.Values().GetBoolDefault(onErrorDataArrayFormat, false)
writeError(ctx, wrapError(ErrClientUnauthorized, "", errors.New(err)), isArray)
}
|
package controller
import (
"fmt"
)
type IndexController struct {
}
func (i *IndexController) Welcome() {
view = "auth_view"
fmt.Println("欢迎来到sixedu")
}
func (i *IndexController) Index() {
view = "auth_view"
fmt.Println("进入到首页")
}
|
// Copyright 2020 PingCAP, Inc.
//
// 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.
//go:build windows
package local
import (
"math"
"github.com/pingcap/errors"
)
// RlimT is the type of rlimit values.
type RlimT = uint64
// return a big value as unlimited, since rlimit verify is skipped in windows.
func GetSystemRLimit() (uint64, error) {
return math.MaxInt32, nil
}
func VerifyRLimit(estimateMaxFiles uint64) error {
return errors.New("Local-backend is not tested on Windows. Run with --check-requirements=false to disable this check, but you are on your own risk.")
}
|
package exasol
import (
"github.com/stretchr/testify/suite"
"testing"
)
type WebsocketTestSuite struct {
suite.Suite
}
func TestWebsocketSuite(t *testing.T) {
suite.Run(t, new(WebsocketTestSuite))
}
func (suite *WebsocketTestSuite) TestSingleHostResolve() {
config := config{Host: "localhost"}
connection := connection{config: &config}
hosts, err := connection.resolveHosts()
suite.NoError(err)
suite.Equal(len(hosts), 1)
suite.Equal(hosts[0], "localhost")
}
func (suite *WebsocketTestSuite) TestMultipleHostResolve() {
config := config{Host: "exasol1,127.0.0.1,exasol3"}
connection := connection{config: &config}
hosts, err := connection.resolveHosts()
suite.NoError(err)
suite.Equal(len(hosts), 3)
suite.Equal(hosts[0], "exasol1")
suite.Equal(hosts[1], "127.0.0.1")
suite.Equal(hosts[2], "exasol3")
}
func (suite *WebsocketTestSuite) TestHostRangeResolve() {
config := config{Host: "exasol1..3"}
connection := connection{config: &config}
hosts, err := connection.resolveHosts()
suite.NoError(err)
suite.Equal(len(hosts), 3)
suite.Equal(hosts[0], "exasol1")
suite.Equal(hosts[1], "exasol2")
suite.Equal(hosts[2], "exasol3")
}
func (suite *WebsocketTestSuite) TestIPRangeResolve() {
config := config{Host: "127.0.0.1..3"}
connection := connection{config: &config}
hosts, err := connection.resolveHosts()
suite.NoError(err)
suite.Equal(len(hosts), 3)
suite.Equal(hosts[0], "127.0.0.1")
suite.Equal(hosts[1], "127.0.0.2")
suite.Equal(hosts[2], "127.0.0.3")
}
|
package upload
import (
"MI/pkg/setting"
"context"
"github.com/qiniu/go-sdk/v7/auth/qbox"
"github.com/qiniu/go-sdk/v7/storage"
"mime/multipart"
)
func UploadFile(file multipart.File,fileSize int64,fileName string)(string,error){
putPolicy := storage.PutPolicy{
Scope: setting.QiNiuYunConf.Bucket,
}
mac := qbox.NewMac(setting.QiNiuYunConf.AccessKey,setting.QiNiuYunConf.SecretKey)
upToken := putPolicy.UploadToken(mac)
cfg := storage.Config{}
// 空间对应的机房
cfg.Zone = &storage.ZoneHuanan
// 是否使用https域名
cfg.UseHTTPS = false
// 上传是否使用CDN上传加速
cfg.UseCdnDomains = false
// 构建表单上传的对象
formUploader := storage.NewFormUploader(&cfg)
ret := storage.PutRet{}
// 可选配置
putExtra := storage.PutExtra{}
err := formUploader.Put(context.Background(), &ret, upToken,fileName, file, fileSize, &putExtra)
if err != nil {
return "",err
}
return setting.QiNiuYunConf.Server+ret.Key ,nil
}
|
package logger
import (
"log"
"os"
"github.com/etf1/kafka-transformer/pkg/logger"
)
// Stdout system out implementation of Logger.Log interface
type Stdout struct {
out *log.Logger
err *log.Logger
}
// StdoutLogger is the default implementation of Log stdout/stderr
func StdoutLogger() logger.Log {
return Stdout{
out: log.New(os.Stdout, "", log.LstdFlags),
err: log.New(os.Stderr, "", log.LstdFlags),
}
}
// Debugf writes a debug log
func (s Stdout) Debugf(format string, args ...interface{}) {
s.out.Printf(format, args...)
}
// Errorf writes an error log
func (s Stdout) Errorf(format string, args ...interface{}) {
s.err.Printf(format, args...)
}
|
package golibs
const R_OK int = 1
const R_ERR int = 0
|
package main
import (
"flag"
"fmt"
"image"
"image/color"
"image/gif"
"log"
"math"
"os"
)
var (
frames = flag.Int("frames", 120, "number of frames")
width = flag.Int("width", 512, "window width")
height = flag.Int("height", 512, "window height")
delay = flag.Int("delay", 10, "delay between frames in 10ms units")
)
func main() {
flag.Usage = usage
flag.Parse()
animate("rotating-square.gif", *width, *height, *frames, *delay)
}
func usage() {
fmt.Fprintln(os.Stderr, "usage: [options]")
flag.PrintDefaults()
os.Exit(2)
}
func animate(name string, width, height, frames, delay int) {
anim := &gif.GIF{
LoopCount: frames,
}
pal := genpal()
for i := 0; i < frames; i++ {
rect := image.Rect(0, 0, width, height)
img := image.NewPaletted(rect, pal)
theta := float64(i) / float64(frames) * 2 * math.Pi
square(img, theta)
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
f, err := os.Create(name)
if err != nil {
log.Fatal(err)
}
defer f.Close()
err = gif.EncodeAll(f, anim)
if err != nil {
log.Fatal(err)
}
}
func genpal() []color.Color {
pal := make([]color.Color, 256)
for i := range pal {
pal[i] = color.RGBA{uint8(i), uint8(i), uint8(i), 255}
}
return pal
}
func square(m *image.Paletted, theta float64) {
rect := m.Bounds()
width := float64(rect.Dx())
height := float64(rect.Dy())
xc := width / 2
yc := height / 2
l := 0.3 * math.Min(width, height)
pts := [][4]float64{
{xc - l, yc - l, xc + l, yc - l},
{xc - l, yc - l, xc - l, yc + l},
{xc + l, yc - l, xc + l, yc + l},
{xc - l, yc + l, xc + l, yc + l},
}
for _, p := range pts {
p[0], p[1] = rotate(p[0], p[1], xc, yc, theta)
p[2], p[3] = rotate(p[2], p[3], xc, yc, theta)
wuline(m, p[0], p[1], p[2], p[3])
}
}
func rotate(x, y, xc, yc float64, theta float64) (xr, yr float64) {
si, co := math.Sincos(theta)
xr = co*(x-xc) - si*(y-yc) + xc
yr = si*(x-xc) + co*(y-yc) + yc
return
}
// https://en.wikipedia.org/wiki/Xiaolin_Wu%27s_line_algorithm
func wuline(m *image.Paletted, x0, y0, x1, y1 float64) {
steep := math.Abs(y1-y0) > math.Abs(x1-x0)
if steep {
x0, y0 = y0, x0
x1, y1 = y1, x1
}
if x0 > x1 {
x0, x1 = x1, x0
y0, y1 = y1, y0
}
dx := x1 - x0
dy := y1 - y0
gradient := 1.0
if dx != 0 {
gradient = dy / dx
}
xend := math.Round(x0)
yend := y0 + gradient*(xend-x0)
xgap := rfpart(x0 + 0.5)
xpxl1 := xend
ypxl1 := ipart(yend)
if steep {
plot(m, ypxl1, xpxl1, rfpart(yend)*xgap)
plot(m, ypxl1+1, xpxl1, fpart(yend)*xgap)
} else {
plot(m, xpxl1, ypxl1, rfpart(yend)*xgap)
plot(m, xpxl1, ypxl1+1, fpart(yend)*xgap)
}
intery := yend + gradient
xend = math.Round(x1)
yend = y1 + gradient*(xend-x1)
xgap = fpart(x1 + 0.5)
xpxl2 := xend
ypxl2 := ipart(yend)
if steep {
plot(m, ypxl2, xpxl2, rfpart(yend)*xgap)
plot(m, ypxl2+1, xpxl2, fpart(yend)*xgap)
} else {
plot(m, xpxl2, ypxl2, rfpart(yend)*xgap)
plot(m, xpxl2, ypxl2+1, fpart(yend)*xgap)
}
if steep {
for x := xpxl1 + 1; x <= xpxl2-1; x++ {
plot(m, ipart(intery), x, rfpart(intery))
plot(m, ipart(intery)+1, x, fpart(intery))
intery = intery + gradient
}
} else {
for x := xpxl1 + 1; x <= xpxl2-1; x++ {
plot(m, x, ipart(intery), rfpart(intery))
plot(m, x, ipart(intery)+1, fpart(intery))
intery = intery + gradient
}
}
}
func plot(m *image.Paletted, x, y, c float64) {
g := uint8(255 * c)
m.SetColorIndex(int(x), int(y), g)
}
func rfpart(x float64) float64 {
return 1 - fpart(x)
}
func ipart(x float64) float64 {
return math.Floor(x)
}
func fpart(x float64) float64 {
return x - math.Floor(x)
}
|
package httpclient
import (
"fmt"
"reflect"
"strings"
"github.com/nelsam/requests/options"
)
var (
registeredOptions = map[string]InputOptionFunc{
"required": InputOptionFunc(options.Required),
"default": InputOptionFunc(options.Default),
"immutable": InputOptionFunc(options.Immutable),
}
optionDefaults map[string]string
fallbackTags []string
)
// FallbackTags returns a list of tag names that are used as fallbacks
// to locate field names. See AddFallbackTag for more details.
func FallbackTags() []string {
if fallbackTags == nil {
fallbackTags = make([]string, 0, 5)
}
return fallbackTags
}
// AddFallbackTag adds a tag name to the list of fallback tag names to
// use when locating a field name. For example, if you use the "db"
// tag and find yourself duplicating the name in both the "db" and
// "request" tags as follows:
//
// type Example struct {
// User `db:"user_id" request:"user_id"`
// }
//
// Then you could update your code to the following:
//
// func init() {
// AddFallbackTag("db")
// }
//
// type Example struct {
// User `db:"user_id"`
// }
//
// Fallback tags will only be added once - duplicates will be ignored.
// Fallbacks will be used in the order that they are added, so if you
// add "db" before "response" (as an example), the "db" tag will be
// preferred over the "response" tag as a fallback.
//
// In all cases, the "request" tag will be preferred over anything
// else. However, an empty name (but non-empty options) will cause
// the fallbacks to be used, as in the following example:
//
// func init() {
// AddFallbackTag("db")
// }
//
// type Example struct {
// // Use the name from the DB, but add the 'required' option
// // for requests.
// User `db:"user_id" request:",required"`
// }
func AddFallbackTag(newTag string) {
tags := FallbackTags()
for _, tag := range tags {
if tag == newTag {
return
}
}
fallbackTags = append(tags, newTag)
}
// OptionDefaults returns a list of default values for options. See
// SetOptionDefault for more details.
func OptionDefaults() map[string]string {
if optionDefaults == nil {
optionDefaults = make(map[string]string)
}
return optionDefaults
}
// SetOptionDefault sets an option to default to a value. By default,
// OptionFuncs that are excluded from a field's options are never
// called, but if you set a default for that option, it will always be
// called with the default value if the option is not provided on the
// struct field. An example:
//
// func init() {
// SetOptionDefault("required", "true")
// }
//
// type Example struct {
// // user_id will be required in the request
// User `db:user_id`
//
// // description will be optional in the request
// Description `request:",required=false"`
// }
func SetOptionDefault(option, value string) {
OptionDefaults()[option] = value
}
// An OptionFunc is a function which takes a field's original value,
// new value (from a request), and a string of option values (anything
// to the right of the = sign in a field's tag option), and returns
// the final new value (parsed from the request value) and any errors encountered.
type OptionFunc func(originalValue, requestValue interface{}, optionValue string) (convertedValue interface{}, err error)
// An InputOptionFunc is an OptionFunc that also accepts a boolean -
// whether or not requestValue is from a request.
type InputOptionFunc func(originalValue, requestValue interface{}, fromRequest bool, optionValue string) (convertedValue interface{}, err error)
type tagOption struct {
name string
value string
}
func (option tagOption) function() InputOptionFunc {
function, _ := registeredOptions[option.name]
return function
}
// RegisterOption can be used to register functions that should be
// called for struct fields with matching option strings. For
// example:
//
// RegisterOption("allow-empty", func(value interface{}, optionValue string) (interface{}, error) {
// if optionValue == "false" {
// if value == nil || value.(string) == "" {
// return nil, errors.New("Cannot be empty")
// }
// }
// return value, nil
// })
//
// type Example struct {
// Name `request:",allow-empty=false"`
// }
//
// Any options without a value (e.g. request:",non-empty") will have
// their value set to "true".
//
// An error will be returned if an OptionFunc is already registered
// for the provided name.
func RegisterOption(name string, optionFunc OptionFunc) error {
if _, ok := registeredOptions[name]; ok {
return fmt.Errorf(`An OptionFunc is already registered for "%s"`, name)
}
registeredOptions[name] = func(orig, new interface{}, fromRequest bool, optionValue string) (interface{}, error) {
return optionFunc(orig, new, optionValue)
}
return nil
}
func RegisterInputOption(name string, inputOptionFunc InputOptionFunc) error {
if _, ok := registeredOptions[name]; ok {
return fmt.Errorf(`An OptionFunc is already registered for "%s"`, name)
}
registeredOptions[name] = inputOptionFunc
return nil
}
// ApplyOptions will attempt to apply any OptionFunc values registered
// with RegisterOption to a struct field. If any of the OptionFuncs
// return an error, the process will immediately return a nil value
// and the returned error.
func ApplyOptions(field reflect.StructField, orig, input interface{}, fromRequest bool) (value interface{}, optionErr error) {
value = input
for _, option := range tagOptions(field) {
inputOptionFunc := option.function()
if inputOptionFunc == nil {
return nil, fmt.Errorf(`Could not find a registered OptionFunc for option "%s"`, option.name)
}
if value, optionErr = inputOptionFunc(orig, value, fromRequest, option.value); optionErr != nil {
return nil, optionErr
}
}
return
}
func tagOptions(field reflect.StructField) []*tagOption {
remaining := field.Tag.Get("request")
options := make([]*tagOption, 0, len(optionDefaults)+5)
for startIdx := strings.IndexRune(remaining, ','); startIdx >= 0; startIdx = strings.IndexRune(remaining, ',') {
// Skip over the ',' character
startIdx++
endIdx := strings.IndexRune(remaining[startIdx:], ',')
if endIdx < 0 {
endIdx = len(remaining)
} else {
endIdx += startIdx
}
currentOption := remaining[startIdx:endIdx]
remaining = remaining[endIdx:]
optionNameEnd := strings.IndexRune(currentOption, '=')
optionNameStart := optionNameEnd + 1
if optionNameEnd < 0 {
optionNameEnd = len(currentOption)
optionNameStart = len(currentOption)
}
option := new(tagOption)
option.name = currentOption[:optionNameEnd]
option.value = currentOption[optionNameStart:]
if option.value == "" {
option.value = "true"
}
options = append(options, option)
}
for name, defaultValue := range optionDefaults {
useDefault := true
for _, option := range options {
if name == option.name {
useDefault = false
break
}
}
if useDefault {
options = append(options, &tagOption{
name: name,
value: defaultValue,
})
}
}
return options
}
func name(field reflect.StructField) string {
name := nameFromTag(field, "request")
for fallback := 0; len(name) == 0 && fallback < len(fallbackTags); fallback++ {
name = nameFromTag(field, fallbackTags[fallback])
}
if len(name) == 0 {
name = strings.ToLower(field.Name)
}
return name
}
func nameFromTag(field reflect.StructField, tagName string) string {
name := field.Tag.Get(tagName)
nameEnd := strings.IndexRune(name, ',')
if nameEnd == -1 {
return name
}
return name[:nameEnd]
}
|
// Copyright 2023 Google LLC. All Rights Reserved.
//
// 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 alpha
import (
"github.com/GoogleCloudPlatform/declarative-resource-client-library/dcl"
)
func DCLHttpRouteSchema() *dcl.Schema {
return &dcl.Schema{
Info: &dcl.Info{
Title: "NetworkServices/HttpRoute",
Description: "The NetworkServices HttpRoute resource",
StructName: "HttpRoute",
},
Paths: &dcl.Paths{
Get: &dcl.Path{
Description: "The function used to get information about a HttpRoute",
Parameters: []dcl.PathParameters{
dcl.PathParameters{
Name: "httpRoute",
Required: true,
Description: "A full instance of a HttpRoute",
},
},
},
Apply: &dcl.Path{
Description: "The function used to apply information about a HttpRoute",
Parameters: []dcl.PathParameters{
dcl.PathParameters{
Name: "httpRoute",
Required: true,
Description: "A full instance of a HttpRoute",
},
},
},
Delete: &dcl.Path{
Description: "The function used to delete a HttpRoute",
Parameters: []dcl.PathParameters{
dcl.PathParameters{
Name: "httpRoute",
Required: true,
Description: "A full instance of a HttpRoute",
},
},
},
DeleteAll: &dcl.Path{
Description: "The function used to delete all HttpRoute",
Parameters: []dcl.PathParameters{
dcl.PathParameters{
Name: "project",
Required: true,
Schema: &dcl.PathParametersSchema{
Type: "string",
},
},
dcl.PathParameters{
Name: "location",
Required: true,
Schema: &dcl.PathParametersSchema{
Type: "string",
},
},
},
},
List: &dcl.Path{
Description: "The function used to list information about many HttpRoute",
Parameters: []dcl.PathParameters{
dcl.PathParameters{
Name: "project",
Required: true,
Schema: &dcl.PathParametersSchema{
Type: "string",
},
},
dcl.PathParameters{
Name: "location",
Required: true,
Schema: &dcl.PathParametersSchema{
Type: "string",
},
},
},
},
},
Components: &dcl.Components{
Schemas: map[string]*dcl.Component{
"HttpRoute": &dcl.Component{
Title: "HttpRoute",
ID: "projects/{{project}}/locations/{{location}}/httpRoutes/{{name}}",
ParentContainer: "project",
LabelsField: "labels",
HasCreate: true,
SchemaProperty: dcl.Property{
Type: "object",
Required: []string{
"name",
"hostnames",
"rules",
"project",
"location",
},
Properties: map[string]*dcl.Property{
"createTime": &dcl.Property{
Type: "string",
Format: "date-time",
GoName: "CreateTime",
ReadOnly: true,
Description: "Output only. The timestamp when the resource was created.",
Immutable: true,
},
"description": &dcl.Property{
Type: "string",
GoName: "Description",
Description: "Optional. A free-text description of the resource. Max length 1024 characters.",
},
"gateways": &dcl.Property{
Type: "array",
GoName: "Gateways",
Description: "Optional. Gateways defines a list of gateways this HttpRoute is attached to, as one of the routing rules to route the requests served by the gateway. Each gateway reference should match the pattern: `projects/*/locations/global/gateways/`",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "string",
GoType: "string",
ResourceReferences: []*dcl.PropertyResourceReference{
&dcl.PropertyResourceReference{
Resource: "Networkservices/Gateway",
Field: "selfLink",
},
},
},
},
"hostnames": &dcl.Property{
Type: "array",
GoName: "Hostnames",
Description: "Required. Hostnames define a set of hosts that should match against the HTTP host header to select a HttpRoute to process the request. Hostname is the fully qualified domain name of a network host, as defined by RFC 1123 with the exception that ip addresses are not allowed. Wildcard hosts are supported as \"*\" (no prefix or suffix allowed).",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "string",
GoType: "string",
},
},
"labels": &dcl.Property{
Type: "object",
AdditionalProperties: &dcl.Property{
Type: "string",
},
GoName: "Labels",
Description: "Optional. Set of label tags associated with the HttpRoute resource.",
},
"location": &dcl.Property{
Type: "string",
GoName: "Location",
Description: "The location for the resource",
Immutable: true,
},
"meshes": &dcl.Property{
Type: "array",
GoName: "Meshes",
Description: "Optional. Meshes defines a list of meshes this HttpRoute is attached to, as one of the routing rules to route the requests served by the mesh. Each mesh reference should match the pattern: `projects/*/locations/global/meshes/` The attached Mesh should be of a type SIDECAR",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "string",
GoType: "string",
ResourceReferences: []*dcl.PropertyResourceReference{
&dcl.PropertyResourceReference{
Resource: "Networkservices/Mesh",
Field: "selfLink",
},
},
},
},
"name": &dcl.Property{
Type: "string",
GoName: "Name",
Description: "Required. Name of the HttpRoute resource. It matches pattern `projects/*/locations/global/httpRoutes/http_route_name>`.",
},
"project": &dcl.Property{
Type: "string",
GoName: "Project",
Description: "The project for the resource",
Immutable: true,
ResourceReferences: []*dcl.PropertyResourceReference{
&dcl.PropertyResourceReference{
Resource: "Cloudresourcemanager/Project",
Field: "name",
Parent: true,
},
},
},
"rules": &dcl.Property{
Type: "array",
GoName: "Rules",
Description: "Required. Rules that define how traffic is routed and handled.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "object",
GoType: "HttpRouteRules",
Properties: map[string]*dcl.Property{
"action": &dcl.Property{
Type: "object",
GoName: "Action",
GoType: "HttpRouteRulesAction",
Description: "The detailed rule defining how to route matched traffic.",
Properties: map[string]*dcl.Property{
"corsPolicy": &dcl.Property{
Type: "object",
GoName: "CorsPolicy",
GoType: "HttpRouteRulesActionCorsPolicy",
Description: "The specification for allowing client side cross-origin requests.",
Properties: map[string]*dcl.Property{
"allowCredentials": &dcl.Property{
Type: "boolean",
GoName: "AllowCredentials",
Description: "In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This translates to the Access-Control-Allow-Credentials header. Default value is false.",
},
"allowHeaders": &dcl.Property{
Type: "array",
GoName: "AllowHeaders",
Description: "Specifies the content for Access-Control-Allow-Headers header.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "string",
GoType: "string",
},
},
"allowMethods": &dcl.Property{
Type: "array",
GoName: "AllowMethods",
Description: "Specifies the content for Access-Control-Allow-Methods header.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "string",
GoType: "string",
},
},
"allowOriginRegexes": &dcl.Property{
Type: "array",
GoName: "AllowOriginRegexes",
Description: "Specifies the regular expression patterns that match allowed origins. For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "string",
GoType: "string",
},
},
"allowOrigins": &dcl.Property{
Type: "array",
GoName: "AllowOrigins",
Description: "Specifies the list of origins that will be allowed to do CORS requests. An origin is allowed if it matches either an item in allow_origins or an item in allow_origin_regexes.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "string",
GoType: "string",
},
},
"disabled": &dcl.Property{
Type: "boolean",
GoName: "Disabled",
Description: "If true, the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.",
},
"exposeHeaders": &dcl.Property{
Type: "array",
GoName: "ExposeHeaders",
Description: "Specifies the content for Access-Control-Expose-Headers header.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "string",
GoType: "string",
},
},
"maxAge": &dcl.Property{
Type: "string",
GoName: "MaxAge",
Description: "Specifies how long result of a preflight request can be cached in seconds. This translates to the Access-Control-Max-Age header.",
},
},
},
"destinations": &dcl.Property{
Type: "array",
GoName: "Destinations",
Description: "The destination to which traffic should be forwarded.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "object",
GoType: "HttpRouteRulesActionDestinations",
Properties: map[string]*dcl.Property{
"serviceName": &dcl.Property{
Type: "string",
GoName: "ServiceName",
Description: "The URL of a BackendService to route traffic to.",
ResourceReferences: []*dcl.PropertyResourceReference{
&dcl.PropertyResourceReference{
Resource: "Compute/BackendService",
Field: "name",
Format: "projects/{{project}}/locations/global/backendServices/{{name}}",
},
},
},
"weight": &dcl.Property{
Type: "integer",
Format: "int64",
GoName: "Weight",
Description: "Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports. If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend. If weights are specified for any one service name, they need to be specified for all of them. If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.",
},
},
},
},
"faultInjectionPolicy": &dcl.Property{
Type: "object",
GoName: "FaultInjectionPolicy",
GoType: "HttpRouteRulesActionFaultInjectionPolicy",
Description: "The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure. As part of fault injection, when clients send requests to a backend service, delays can be introduced on a percentage of requests before sending those requests to the backend service. Similarly requests from clients can be aborted for a percentage of requests. timeout and retry_policy will be ignored by clients that are configured with a fault_injection_policy",
Properties: map[string]*dcl.Property{
"abort": &dcl.Property{
Type: "object",
GoName: "Abort",
GoType: "HttpRouteRulesActionFaultInjectionPolicyAbort",
Description: "The specification for aborting to client requests.",
Properties: map[string]*dcl.Property{
"httpStatus": &dcl.Property{
Type: "integer",
Format: "int64",
GoName: "HttpStatus",
Description: "The HTTP status code used to abort the request. The value must be between 200 and 599 inclusive.",
},
"percentage": &dcl.Property{
Type: "integer",
Format: "int64",
GoName: "Percentage",
Description: "The percentage of traffic which will be aborted. The value must be between [0, 100]",
},
},
},
"delay": &dcl.Property{
Type: "object",
GoName: "Delay",
GoType: "HttpRouteRulesActionFaultInjectionPolicyDelay",
Description: "The specification for injecting delay to client requests.",
Properties: map[string]*dcl.Property{
"fixedDelay": &dcl.Property{
Type: "string",
GoName: "FixedDelay",
Description: "Specify a fixed delay before forwarding the request.",
},
"percentage": &dcl.Property{
Type: "integer",
Format: "int64",
GoName: "Percentage",
Description: "The percentage of traffic on which delay will be injected. The value must be between [0, 100]",
},
},
},
},
},
"redirect": &dcl.Property{
Type: "object",
GoName: "Redirect",
GoType: "HttpRouteRulesActionRedirect",
Description: "If set, the request is directed as configured by this field.",
Properties: map[string]*dcl.Property{
"hostRedirect": &dcl.Property{
Type: "string",
GoName: "HostRedirect",
Description: "The host that will be used in the redirect response instead of the one that was supplied in the request.",
},
"httpsRedirect": &dcl.Property{
Type: "boolean",
GoName: "HttpsRedirect",
Description: "If set to true, the URL scheme in the redirected request is set to https. If set to false, the URL scheme of the redirected request will remain the same as that of the request. The default is set to false.",
},
"pathRedirect": &dcl.Property{
Type: "string",
GoName: "PathRedirect",
Description: "The path that will be used in the redirect response instead of the one that was supplied in the request. path_redirect can not be supplied together with prefix_redirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.",
},
"portRedirect": &dcl.Property{
Type: "integer",
Format: "int64",
GoName: "PortRedirect",
Description: "The port that will be used in the redirected request instead of the one that was supplied in the request.",
},
"prefixRewrite": &dcl.Property{
Type: "string",
GoName: "PrefixRewrite",
Description: "Indicates that during redirection, the matched prefix (or path) should be swapped with this value. This option allows URLs be dynamically created based on the request.",
},
"responseCode": &dcl.Property{
Type: "string",
GoName: "ResponseCode",
GoType: "HttpRouteRulesActionRedirectResponseCodeEnum",
Description: "The HTTP Status code to use for the redirect. Possible values: MOVED_PERMANENTLY_DEFAULT, FOUND, SEE_OTHER, TEMPORARY_REDIRECT, PERMANENT_REDIRECT",
Enum: []string{
"MOVED_PERMANENTLY_DEFAULT",
"FOUND",
"SEE_OTHER",
"TEMPORARY_REDIRECT",
"PERMANENT_REDIRECT",
},
},
"stripQuery": &dcl.Property{
Type: "boolean",
GoName: "StripQuery",
Description: "if set to true, any accompanying query portion of the original URL is removed prior to redirecting the request. If set to false, the query portion of the original URL is retained. The default is set to false.",
},
},
},
"requestHeaderModifier": &dcl.Property{
Type: "object",
GoName: "RequestHeaderModifier",
GoType: "HttpRouteRulesActionRequestHeaderModifier",
Description: "The specification for modifying the headers of a matching request prior to delivery of the request to the destination.",
Properties: map[string]*dcl.Property{
"add": &dcl.Property{
Type: "object",
AdditionalProperties: &dcl.Property{
Type: "string",
},
GoName: "Add",
Description: "Add the headers with given map where key is the name of the header, value is the value of the header.",
},
"remove": &dcl.Property{
Type: "array",
GoName: "Remove",
Description: "Remove headers (matching by header names) specified in the list.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "string",
GoType: "string",
},
},
"set": &dcl.Property{
Type: "object",
AdditionalProperties: &dcl.Property{
Type: "string",
},
GoName: "Set",
Description: "Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.",
},
},
},
"requestMirrorPolicy": &dcl.Property{
Type: "object",
GoName: "RequestMirrorPolicy",
GoType: "HttpRouteRulesActionRequestMirrorPolicy",
Description: "Specifies the policy on how requests intended for the routes destination are shadowed to a separate mirrored destination. Proxy will not wait for the shadow destination to respond before returning the response. Prior to sending traffic to the shadow service, the host/authority header is suffixed with -shadow.",
Properties: map[string]*dcl.Property{
"destination": &dcl.Property{
Type: "object",
GoName: "Destination",
GoType: "HttpRouteRulesActionRequestMirrorPolicyDestination",
Description: "The destination the requests will be mirrored to. The weight of the destination will be ignored.",
Properties: map[string]*dcl.Property{
"serviceName": &dcl.Property{
Type: "string",
GoName: "ServiceName",
Description: "The URL of a BackendService to route traffic to.",
ResourceReferences: []*dcl.PropertyResourceReference{
&dcl.PropertyResourceReference{
Resource: "Compute/BackendService",
Field: "name",
Format: "projects/{{project}}/locations/global/backendServices/{{name}}",
},
},
},
"weight": &dcl.Property{
Type: "integer",
Format: "int64",
GoName: "Weight",
Description: "Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports. If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend. If weights are specified for any one service name, they need to be specified for all of them. If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.",
},
},
},
},
},
"responseHeaderModifier": &dcl.Property{
Type: "object",
GoName: "ResponseHeaderModifier",
GoType: "HttpRouteRulesActionResponseHeaderModifier",
Description: "The specification for modifying the headers of a response prior to sending the response back to the client.",
Properties: map[string]*dcl.Property{
"add": &dcl.Property{
Type: "object",
AdditionalProperties: &dcl.Property{
Type: "string",
},
GoName: "Add",
Description: "Add the headers with given map where key is the name of the header, value is the value of the header.",
},
"remove": &dcl.Property{
Type: "array",
GoName: "Remove",
Description: "Remove headers (matching by header names) specified in the list.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "string",
GoType: "string",
},
},
"set": &dcl.Property{
Type: "object",
AdditionalProperties: &dcl.Property{
Type: "string",
},
GoName: "Set",
Description: "Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.",
},
},
},
"retryPolicy": &dcl.Property{
Type: "object",
GoName: "RetryPolicy",
GoType: "HttpRouteRulesActionRetryPolicy",
Description: "Specifies the retry policy associated with this route.",
Properties: map[string]*dcl.Property{
"numRetries": &dcl.Property{
Type: "integer",
Format: "int64",
GoName: "NumRetries",
Description: "Specifies the allowed number of retries. This number must be > 0. If not specified, default to 1.",
},
"perTryTimeout": &dcl.Property{
Type: "string",
GoName: "PerTryTimeout",
Description: "Specifies a non-zero timeout per retry attempt.",
},
"retryConditions": &dcl.Property{
Type: "array",
GoName: "RetryConditions",
Description: "Specifies one or more conditions when this retry policy applies. Valid values are: 5xx: Proxy will attempt a retry if the destination service responds with any 5xx response code, of if the destination service does not respond at all, example: disconnect, reset, read timeout, connection failure and refused streams. gateway-error: Similar to 5xx, but only applies to response codes 502, 503, 504. reset: Proxy will attempt a retry if the destination service does not respond at all (disconnect/reset/read timeout) connect-failure: Proxy will retry on failures connecting to destination for example due to connection timeouts. retriable-4xx: Proxy will retry fro retriable 4xx response codes. Currently the only retriable error supported is 409. refused-stream: Proxy will retry if the destination resets the stream with a REFUSED_STREAM error code. This reset type indicates that it is safe to retry.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "string",
GoType: "string",
},
},
},
},
"timeout": &dcl.Property{
Type: "string",
GoName: "Timeout",
Description: "Specifies the timeout for selected route. Timeout is computed from the time the request has been fully processed (i.e. end of stream) up until the response has been completely processed. Timeout includes all retries.",
},
"urlRewrite": &dcl.Property{
Type: "object",
GoName: "UrlRewrite",
GoType: "HttpRouteRulesActionUrlRewrite",
Description: "The specification for rewrite URL before forwarding requests to the destination.",
Properties: map[string]*dcl.Property{
"hostRewrite": &dcl.Property{
Type: "string",
GoName: "HostRewrite",
Description: "Prior to forwarding the request to the selected destination, the requests host header is replaced by this value.",
},
"pathPrefixRewrite": &dcl.Property{
Type: "string",
GoName: "PathPrefixRewrite",
Description: "Prior to forwarding the request to the selected destination, the matching portion of the requests path is replaced by this value.",
},
},
},
},
},
"matches": &dcl.Property{
Type: "array",
GoName: "Matches",
Description: "A list of matches define conditions used for matching the rule against incoming HTTP requests. Each match is independent, i.e. this rule will be matched if ANY one of the matches is satisfied.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "object",
GoType: "HttpRouteRulesMatches",
Properties: map[string]*dcl.Property{
"fullPathMatch": &dcl.Property{
Type: "string",
GoName: "FullPathMatch",
Description: "The HTTP request path value should exactly match this value. Only one of full_path_match, prefix_match, or regex_match should be used.",
Conflicts: []string{
"prefixMatch",
"regexMatch",
},
},
"headers": &dcl.Property{
Type: "array",
GoName: "Headers",
Description: "Specifies a list of HTTP request headers to match against. ALL of the supplied headers must be matched.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "object",
GoType: "HttpRouteRulesMatchesHeaders",
Properties: map[string]*dcl.Property{
"exactMatch": &dcl.Property{
Type: "string",
GoName: "ExactMatch",
Description: "The value of the header should match exactly the content of exact_match.",
Conflicts: []string{
"regexMatch",
"prefixMatch",
"presentMatch",
"suffixMatch",
"rangeMatch",
},
},
"header": &dcl.Property{
Type: "string",
GoName: "Header",
Description: "The name of the HTTP header to match against.",
},
"invertMatch": &dcl.Property{
Type: "boolean",
GoName: "InvertMatch",
Description: "If specified, the match result will be inverted before checking. Default value is set to false.",
},
"prefixMatch": &dcl.Property{
Type: "string",
GoName: "PrefixMatch",
Description: "The value of the header must start with the contents of prefix_match.",
Conflicts: []string{
"exactMatch",
"regexMatch",
"presentMatch",
"suffixMatch",
"rangeMatch",
},
},
"presentMatch": &dcl.Property{
Type: "boolean",
GoName: "PresentMatch",
Description: "A header with header_name must exist. The match takes place whether or not the header has a value.",
Conflicts: []string{
"exactMatch",
"regexMatch",
"prefixMatch",
"suffixMatch",
"rangeMatch",
},
},
"rangeMatch": &dcl.Property{
Type: "object",
GoName: "RangeMatch",
GoType: "HttpRouteRulesMatchesHeadersRangeMatch",
Description: "If specified, the rule will match if the request header value is within the range.",
Conflicts: []string{
"exactMatch",
"regexMatch",
"prefixMatch",
"presentMatch",
"suffixMatch",
},
Properties: map[string]*dcl.Property{
"end": &dcl.Property{
Type: "integer",
Format: "int64",
GoName: "End",
Description: "End of the range (exclusive)",
},
"start": &dcl.Property{
Type: "integer",
Format: "int64",
GoName: "Start",
Description: "Start of the range (inclusive)",
},
},
},
"regexMatch": &dcl.Property{
Type: "string",
GoName: "RegexMatch",
Description: "The value of the header must match the regular expression specified in regex_match. For regular expression grammar, please see: https://github.com/google/re2/wiki/Syntax",
Conflicts: []string{
"exactMatch",
"prefixMatch",
"presentMatch",
"suffixMatch",
"rangeMatch",
},
},
"suffixMatch": &dcl.Property{
Type: "string",
GoName: "SuffixMatch",
Description: "The value of the header must end with the contents of suffix_match.",
Conflicts: []string{
"exactMatch",
"regexMatch",
"prefixMatch",
"presentMatch",
"rangeMatch",
},
},
},
},
},
"ignoreCase": &dcl.Property{
Type: "boolean",
GoName: "IgnoreCase",
Description: "Specifies if prefix_match and full_path_match matches are case sensitive. The default value is false.",
},
"prefixMatch": &dcl.Property{
Type: "string",
GoName: "PrefixMatch",
Description: "The HTTP request path value must begin with specified prefix_match. prefix_match must begin with a /. Only one of full_path_match, prefix_match, or regex_match should be used.",
Conflicts: []string{
"fullPathMatch",
"regexMatch",
},
},
"queryParameters": &dcl.Property{
Type: "array",
GoName: "QueryParameters",
Description: "Specifies a list of query parameters to match against. ALL of the query parameters must be matched.",
SendEmpty: true,
ListType: "list",
Items: &dcl.Property{
Type: "object",
GoType: "HttpRouteRulesMatchesQueryParameters",
Properties: map[string]*dcl.Property{
"exactMatch": &dcl.Property{
Type: "string",
GoName: "ExactMatch",
Description: "The value of the query parameter must exactly match the contents of exact_match. Only one of exact_match, regex_match, or present_match must be set.",
Conflicts: []string{
"regexMatch",
"presentMatch",
},
},
"presentMatch": &dcl.Property{
Type: "boolean",
GoName: "PresentMatch",
Description: "Specifies that the QueryParameterMatcher matches if request contains query parameter, irrespective of whether the parameter has a value or not. Only one of exact_match, regex_match, or present_match must be set.",
Conflicts: []string{
"exactMatch",
"regexMatch",
},
},
"queryParameter": &dcl.Property{
Type: "string",
GoName: "QueryParameter",
Description: "The name of the query parameter to match.",
},
"regexMatch": &dcl.Property{
Type: "string",
GoName: "RegexMatch",
Description: "The value of the query parameter must match the regular expression specified by regex_match. For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax Only one of exact_match, regex_match, or present_match must be set.",
Conflicts: []string{
"exactMatch",
"presentMatch",
},
},
},
},
},
"regexMatch": &dcl.Property{
Type: "string",
GoName: "RegexMatch",
Description: "The HTTP request path value must satisfy the regular expression specified by regex_match after removing any query parameters and anchor supplied with the original URL. For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax Only one of full_path_match, prefix_match, or regex_match should be used.",
Conflicts: []string{
"fullPathMatch",
"prefixMatch",
},
},
},
},
},
},
},
},
"selfLink": &dcl.Property{
Type: "string",
GoName: "SelfLink",
ReadOnly: true,
Description: "Output only. Server-defined URL of this resource",
Immutable: true,
},
"updateTime": &dcl.Property{
Type: "string",
Format: "date-time",
GoName: "UpdateTime",
ReadOnly: true,
Description: "Output only. The timestamp when the resource was updated.",
Immutable: true,
},
},
},
},
},
},
}
}
|
package crypto
import "testing"
func TestMd5File(t *testing.T) {
md5 := Md5String([]byte("aaa"))
if len(md5) != 32 {
t.Error(md5)
}
t.Log(md5)
}
func TestMd5FileByPath(t *testing.T) {
md5, err := Md5FileByPath("./md5")
if err != nil {
t.Error(err)
}
t.Log(md5)
}
|
package main
import (
"fmt"
"strconv"
)
func longDiv(a int, b int, max int) (string,int) {
remMap := make(map[int]int)
resStr := ""
hasDot := false
p := 0
for x := 0; x <= max; x++ {
first := true
for ; b > a ; a = a * 10 {
if !hasDot {
hasDot = true
if len(resStr) == 0 {
resStr += "0."
} else {
resStr += "."
}
}
if first {
first = false
} else {
resStr += "0"
p++
}
}
resStr += strconv.Itoa(a/b)
a = a % b
if remMap[a] != 0 {
// fmt.Printf("%s Repeats from %d to %d\n", resStr, remMap[a], p)
return resStr, p - remMap[a]
} else {
remMap[a] = p
}
if a == 0 {
return resStr, 0
}
p++
}
return resStr, 0
}
func main() {
numStr := ""
cycLen := 0
longX := 0
for x := 2 ; x < 1000; x++ {
s, c := longDiv(1,x,20000)
// fmt.Println(c)
if c > cycLen {
cycLen = c
numStr = s
longX = x
}
}
fmt.Println(numStr)
fmt.Println(len(numStr))
fmt.Println(cycLen)
fmt.Println(longX)
}
|
package rating
// GetRequest request for getting a rating
type GetRequest struct {
ID string
}
// GetResponse response after getting a rating
type GetResponse struct {
ID string `json:"id,omitempty"`
Stars string `json:"stars,omitempty"`
}
// // httpRequester makes it possible to mock or intercept http request
// type httpRequester interface {
// Do(*http.Request) (*http.Response, error)
// }
|
// 8. Detect AES in ECB mode
package main
import (
"bufio"
"crypto/aes"
"encoding/hex"
"fmt"
"io"
"os"
)
func main() {
files := os.Args[1:]
if len(files) == 0 {
if err := detect(os.Stdin); err != nil {
fmt.Fprintln(os.Stderr, err)
}
return
}
for _, file := range files {
f, err := os.Open(file)
if err != nil {
fmt.Fprintln(os.Stderr, err)
continue
}
if err := detect(f); err != nil {
fmt.Fprintln(os.Stderr, err)
}
f.Close()
}
}
// detect reads hex-encoded input, detects ECB, and prints the plaintext.
func detect(in io.Reader) error {
input := bufio.NewScanner(in)
for input.Scan() {
line, err := hex.DecodeString(input.Text())
if err != nil {
return err
}
if HasIdenticalBlocks(line, aes.BlockSize) {
fmt.Println(hex.EncodeToString(line))
}
}
return input.Err()
}
// HasIdenticalBlocks returns true if any block in the buffer appears more than once.
func HasIdenticalBlocks(buf []byte, blockSize int) bool {
m := make(map[string]bool)
for _, block := range Subdivide(buf, blockSize) {
s := string(block)
if m[s] {
return true
}
m[s] = true
}
return false
}
// Subdivide divides a buffer into blocks.
func Subdivide(buf []byte, blockSize int) [][]byte {
var blocks [][]byte
for len(buf) >= blockSize {
// Return pointers, not copies.
blocks = append(blocks, buf[:blockSize])
buf = buf[blockSize:]
}
return blocks
}
|
package main
import (
"archive/tar"
"bufio"
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"log"
"net"
"net/http"
"os"
"os/exec"
"path/filepath"
"regexp"
"strings"
"time"
"github.com/boot2docker/boot2docker-cli/driver"
)
// Try if addr tcp://addr is readable for n times at wait interval.
func read(addr string, n int, wait time.Duration) error {
var lastErr error
for i := 0; i < n; i++ {
if B2D.Verbose {
fmt.Printf("Connecting to tcp://%v (attempt #%d)", addr, i)
}
conn, err := net.DialTimeout("tcp", addr, 1*time.Second)
if err != nil {
lastErr = err
time.Sleep(wait)
continue
}
defer conn.Close()
conn.SetDeadline(time.Now().Add(1 * time.Second))
if _, err = conn.Read(make([]byte, 1)); err != nil {
lastErr = err
time.Sleep(wait)
continue
}
return nil
}
return lastErr
}
// Check if an addr can be successfully connected.
func ping(addr string) bool {
conn, err := net.Dial("tcp", addr)
if err != nil {
return false
}
defer conn.Close()
return true
}
// Download the url to the dest path.
func download(dest, url string) error {
rsp, err := http.Get(url)
if err != nil {
return err
}
defer rsp.Body.Close()
// Create the dest dir.
if err := os.MkdirAll(filepath.Dir(dest), 0755); err != nil {
return err
}
f, err := os.Create(fmt.Sprintf("%s.download", dest))
if err != nil {
return err
}
defer os.Remove(f.Name())
if _, err := io.Copy(f, rsp.Body); err != nil {
// TODO: display download progress?
return err
}
if err := f.Close(); err != nil {
return err
}
if _, err := os.Stat(dest); err == nil {
backup_dest := dest + ".bak"
os.Remove(backup_dest)
if err := os.Rename(dest, backup_dest); err != nil {
return err
}
}
if err := os.Rename(f.Name(), dest); err != nil {
return err
}
return nil
}
// Get latest release tag name (e.g. "v0.6.0") from a repo on GitHub.
func getLatestReleaseName(url string) (string, error) {
rsp, err := http.Get(url)
if err != nil {
return "", err
}
defer rsp.Body.Close()
var t []struct {
TagName string `json:"tag_name"`
}
body, err := ioutil.ReadAll(rsp.Body)
if err != nil {
return "", err
}
if err := json.Unmarshal(body, &t); err != nil {
var e struct {
Message string
DocumentationUrl string
}
if err := json.Unmarshal(body, &e); err != nil {
return "", fmt.Errorf("Error decoding %s\nbody: %s", err, body)
}
return "", fmt.Errorf("Error getting releases: %s\n see %s", e.Message, e.DocumentationUrl)
}
if len(t) == 0 {
return "", fmt.Errorf("no releases found")
}
return t[0].TagName, nil
}
func cmdInteractive(m driver.Machine, args ...string) error {
cmd := getSSHCommand(m, args...)
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd.Run()
}
//swiped from dotcloud/docker/utils/utils.go
func CopyFile(src, dst string) (int64, error) {
if src == dst {
return 0, nil
}
sf, err := os.Open(src)
if err != nil {
return 0, err
}
defer sf.Close()
if err := os.Remove(dst); err != nil && !os.IsNotExist(err) {
return 0, err
}
df, err := os.Create(dst)
if err != nil {
return 0, err
}
defer df.Close()
return io.Copy(df, sf)
}
func reader(r io.Reader) {
buf := make([]byte, 1024)
for {
_, err := io.ReadAtLeast(r, buf[:], 20)
if err != nil {
return
}
}
}
func getSSHCommand(m driver.Machine, args ...string) *exec.Cmd {
DefaultSSHArgs := []string{
"-o", "IdentitiesOnly=yes",
"-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"-o", "LogLevel=quiet", // suppress "Warning: Permanently added '[localhost]:2022' (ECDSA) to the list of known hosts."
"-p", fmt.Sprintf("%d", m.GetSSHPort()),
"-i", B2D.SSHKey,
"docker@localhost",
}
sshArgs := append(DefaultSSHArgs, args...)
cmd := exec.Command(B2D.SSH, sshArgs...)
if B2D.Verbose {
cmd.Stderr = os.Stderr
log.Printf("executing: %v %v", cmd.Path, strings.Join(cmd.Args, " "))
}
return cmd
}
func RequestIPFromSSH(m driver.Machine) (string, error) {
cmd := getSSHCommand(m, "ip addr show dev eth1")
b, err := cmd.Output()
if err != nil {
return "", err
}
out := string(b)
if B2D.Verbose {
fmt.Printf("SSH returned: %s\nEND SSH\n", out)
}
// parse to find: inet 192.168.59.103/24 brd 192.168.59.255 scope global eth1
lines := strings.Split(out, "\n")
for _, line := range lines {
vals := strings.Split(strings.TrimSpace(line), " ")
if len(vals) >= 2 && vals[0] == "inet" {
return vals[1][:strings.Index(vals[1], "/")], nil
}
}
return "", fmt.Errorf("No IP address found %s", out)
}
func RequestSocketFromSSH(m driver.Machine) (string, error) {
cmd := getSSHCommand(m, "grep tcp:// /proc/$(cat /var/run/docker.pid)/cmdline")
b, err := cmd.Output()
if err != nil {
return "", err
}
out := string(b)
if B2D.Verbose {
fmt.Printf("SSH returned: %s\nEND SSH\n", out)
}
// Lets only use the first one - its possible to specify more than one...
lines := strings.Split(out, "\n")
tcpRE := regexp.MustCompile(`^(tcp://)(0.0.0.0)(:.*)`)
if s := tcpRE.FindStringSubmatch(lines[0]); s != nil {
IP, err := RequestIPFromSSH(m)
if err != nil {
return "", err
}
return s[1] + IP + s[3], nil
}
if !strings.HasPrefix(lines[0], "tcp://") {
return "", fmt.Errorf("Error requesting Docker Socket: %s", lines[0])
}
return lines[0], nil
}
// use the serial port socket to ask what the VM's host only IP is
func RequestIPFromSerialPort(socket string) (string, error) {
c, err := net.Dial("unix", socket)
if err != nil {
return "", err
}
defer c.Close()
c.SetDeadline(time.Now().Add(time.Second))
line := ""
_, err = c.Write([]byte("\r"))
_, err = c.Write([]byte("docker\r"))
IP := ""
fullLog := ""
for IP == "" {
_, err := c.Write([]byte("ip addr show dev eth1\r"))
if err != nil {
return "", err
}
time.Sleep(1 * time.Second)
buf := make([]byte, 1024)
for {
n, err := c.Read(buf[:])
if err != nil {
return "", err
}
line = line + string(buf[0:n])
fullLog += string(buf[0:n])
if strings.Contains(line, "\n") {
//go looking for the string we want, and chomp line to after the \n
if i := strings.IndexAny(line, "\n"); i != -1 {
// inet 10.180.1.3/16 brd 10.180.255.255 scope global wlan0
inetRE := regexp.MustCompile(`^[\t ]*inet ([0-9.]*).*$`)
if ip := inetRE.FindStringSubmatch(line[:i]); ip != nil {
IP = ip[1]
// clean up
break
} else {
line = line[i+1:]
}
}
}
}
}
go reader(c)
//give us time reader clean up
time.Sleep(1 * time.Second)
if IP == "" && B2D.Verbose {
fmt.Printf(fullLog)
}
return IP, nil
}
// TODO: need to add or abstract to get a Serial coms version
// RequestCertsUsingSSH requests certs using SSH.
// The assumption is that if the certs are in b2d:/home/docker/.docker
// then the daemon is using TLS. We can't assume that because there are
// certs in the local host's user dir, that the server is using them, so
// for now, make sure things are updated from the server. (for `docker shellinit`)
func RequestCertsUsingSSH(m driver.Machine) (string, error) {
cmd := getSSHCommand(m, "tar c /home/docker/.docker/*.pem")
certDir := ""
b, err := cmd.Output()
if err == nil {
dir, err := cfgDir(".boot2docker")
if err != nil {
return "", err
}
certDir = filepath.Join(dir, "certs", m.GetName())
// Open the tar archive for reading.
r := bytes.NewReader(b)
tr := tar.NewReader(r)
// Iterate through the files in the archive.
for {
hdr, err := tr.Next()
if err == io.EOF {
// end of tar archive
break
}
if err != nil {
return "", err
}
filename := filepath.Base(hdr.Name)
if err := os.MkdirAll(certDir, 0755); err != nil {
return "", err
}
certFile := filepath.Join(certDir, filename)
fmt.Fprintf(os.Stderr, "Writing %s\n", certFile)
f, err := os.Create(certFile)
if err != nil {
return "", err
}
w := bufio.NewWriter(f)
if _, err := io.Copy(w, tr); err != nil {
return "", err
}
w.Flush()
}
}
return certDir, nil
}
|
package main
import (
"encoding/json"
"fmt"
"github/gorilla/mux"
"io/ioutil"
"log"
"net/http"
"time"
)
const month = time.Hour * 24 * 30
var topLangs map[string][]string
func home(w http.ResponseWriter, _ *http.Request) {
fmt.Fprint(w, topLangs)
}
func getRepos() error {
topLangs = make(map[string][]string)
resp, err := http.Get(fmt.Sprintf("https://api.github.com/search/repositories?q=created:>%v&sort=stars&order=desc", time.Now().Add(month*-1).Format("2006-01-02")))
if err != nil {
return err
}
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
var results map[string]interface{}
err = json.Unmarshal(data, &results)
if err != nil {
return err
}
items := results["items"].([]interface{})
for i, item := range items {
if i == 100 {
break
}
repo := item.(map[string]interface{})
if repo["language"] != nil {
lang := repo["language"].(string)
topLangs[lang] = append(topLangs[lang], repo["html_url"].(string))
}
}
return nil
}
func main() {
err := getRepos()
if err != nil {
fmt.Print(err)
return
}
router := mux.NewRouter().StrictSlash(true)
router.HandleFunc("/", home)
log.Fatal(http.ListenAndServe(":8081", router))
}
|
package main
import "fmt"
//先定义接口 一般以er结尾 根据接口实现功能
type Humaner2 interface { //子集
//方法 方法的声明
sayhi()
}
type Personer interface { //超集
Humaner2 //继承sayhi()
sing(string)
}
type student13 struct {
name string
age int
score int
}
func (s *student13)sayhi() {
fmt.Printf("大家好，我是%s,今年%d岁，我的成绩%d分\n",s.name,s.age,s.score)
}
func (s *student13)sing(name string) {
fmt.Println("我为大家唱首歌",name)
}
func main1301() {
//接口类型变量定义
var h Humaner2
var stu student13 = student13{"小吴",18,59}
h = &stu
h.sayhi()
//接口类型变量定义
var p Personer
p = &stu
p.sayhi()
p.sing("大碗面")
}
func main() {
//接口类型变量定义
var h Humaner2 //子集
var p Personer //超集
var stu student13 = student13{"小吴",18,59}
p = &stu
//将一个接口赋值给另一个接口
//超集中包含所有子集的方法
h = p //ok
h.sayhi()
//子集不包含超集
//不能将子集赋值给超集
//p = h //err
//p.sayhi()
//p.sing("大碗面")
}
|
package seev
import (
"encoding/xml"
"github.com/thought-machine/finance-messaging/iso20022"
)
type Document03800204 struct {
XMLName xml.Name `xml:"urn:iso:std:iso:20022:tech:xsd:seev.038.002.04 Document"`
Message *CorporateActionNarrative002V04 `xml:"CorpActnNrrtv"`
}
func (d *Document03800204) AddMessage() *CorporateActionNarrative002V04 {
d.Message = new(CorporateActionNarrative002V04)
return d.Message
}
// Scope
// The CorporateActionNarrative message is sent between an account servicer and an account owner or its designated agent to cater for tax reclaims, restrictions, documentation requirements. This message is bi-directional.
// Usage
// The message may also be used to:
// - re-send a message previously sent (the sub-function of the message is Duplicate),
// - provide a third party with a copy of a message for information (the sub-function of the message is Copy),
// - re-send to a third party a copy of a message for information (the sub-function of the message is Copy Duplicate),
// using the relevant elements in the business application header (BAH).
type CorporateActionNarrative002V04 struct {
// General information about the safekeeping account and the account owner.
AccountDetails *iso20022.AccountIdentification37Choice `xml:"AcctDtls,omitempty"`
// Provides information about the securitised right for entitlement.
UnderlyingSecurity *iso20022.SecurityIdentification20 `xml:"UndrlygScty,omitempty"`
// General information about the corporate action event.
CorporateActionGeneralInformation *iso20022.CorporateActionGeneralInformation102 `xml:"CorpActnGnlInf"`
// Provides additional information.
AdditionalInformation *iso20022.UpdatedAdditionalInformation10 `xml:"AddtlInf"`
// Additional information that can not be captured in the structured fields and/or any other specific block.
SupplementaryData []*iso20022.SupplementaryData1 `xml:"SplmtryData,omitempty"`
}
func (c *CorporateActionNarrative002V04) AddAccountDetails() *iso20022.AccountIdentification37Choice {
c.AccountDetails = new(iso20022.AccountIdentification37Choice)
return c.AccountDetails
}
func (c *CorporateActionNarrative002V04) AddUnderlyingSecurity() *iso20022.SecurityIdentification20 {
c.UnderlyingSecurity = new(iso20022.SecurityIdentification20)
return c.UnderlyingSecurity
}
func (c *CorporateActionNarrative002V04) AddCorporateActionGeneralInformation() *iso20022.CorporateActionGeneralInformation102 {
c.CorporateActionGeneralInformation = new(iso20022.CorporateActionGeneralInformation102)
return c.CorporateActionGeneralInformation
}
func (c *CorporateActionNarrative002V04) AddAdditionalInformation() *iso20022.UpdatedAdditionalInformation10 {
c.AdditionalInformation = new(iso20022.UpdatedAdditionalInformation10)
return c.AdditionalInformation
}
func (c *CorporateActionNarrative002V04) AddSupplementaryData() *iso20022.SupplementaryData1 {
newValue := new(iso20022.SupplementaryData1)
c.SupplementaryData = append(c.SupplementaryData, newValue)
return newValue
}
|
package basicarray
import "fmt"
func init() {
fmt.Println("package basicarray init()")
}
/*
/* function prints incoming slice
*/
func PrintSlice(slice []string, suffix string) {
for i := range slice {
slice[i] = slice[i] + suffix
}
fmt.Println(slice)
}
/*
/* function prints length and capacity of incoming array slice
*/
func PrintSliceLenCap(slice []string) {
fmt.Printf("array %T length is %v", slice, len(slice))
fmt.Println()
fmt.Printf("array %T capacity is %v", slice, cap(slice))
fmt.Println()
}
//printArrayBefore prints array
func PrintArrayBefore(array []string) {
fmt.Println("array before", array)
fmt.Println()
}
//PrintArrayAfter prints array with words "array after"
func PrintArrayAfter(array []string) {
fmt.Println("array after", array)
fmt.Println()
}
|
package tasks
import (
"fmt"
"strconv"
)
type TaskToggler interface {
ToggleTask(int, bool) error
}
// ToggleTasks sets one or several task to the value passed as done
func ToggleTasks(store TaskToggler, args []string, done bool) {
for _, arg := range args {
id, err := strconv.Atoi(arg)
if err != nil {
fmt.Printf("%d is not a valid ID", id)
}
err = store.ToggleTask(id, done)
if err != nil {
fmt.Println(err)
}
}
}
|
package httpclient
import (
"fmt"
"strings"
)
// UnusedFields is an error type for input values that were not used
// in a request.
type UnusedFields struct {
params map[string]interface{}
matched set
missing []string
}
// HasMissing returns whether or not this error knows about any input
// values that were not used in a request.
func (err *UnusedFields) HasMissing() bool {
return err.NumMissing() > 0
}
// NumMissing returns the number of input values that were not used in
// a request that this error knows about.
func (err *UnusedFields) NumMissing() int {
return len(err.params) - len(err.matched)
}
// parseMissing is used to find the input values that had no matching
// fields in a request.
func (err *UnusedFields) parseMissing() {
err.missing = make([]string, 0, err.NumMissing())
for param := range err.params {
hasMatch := false
for _, found := range err.matched {
if param == found {
hasMatch = true
break
}
}
if !hasMatch {
err.missing = append(err.missing, param)
}
}
}
// Fields returns the request names of the fields that had no
// corresponding struct fields in a request.
func (err *UnusedFields) Fields() []string {
if err.missing == nil {
err.parseMissing()
}
return err.missing
}
// Error returns an error message listing which fields could not be
// found in the target struct.
func (err *UnusedFields) Error() string {
return fmt.Sprintf("Request fields found with no matching struct fields: %s",
strings.Join(err.Fields(), ", "))
}
|
/* For license and copyright information please see LEGAL file in repository */
package approuter
// AuthorizeWhich will authorize by ConnectionData.AccessControl.Which
func (sd *StreamData) AuthorizeWhich() {
// Check requested user have enough access
var notAuthorize bool
for _, service := range sd.ConnectionData.AccessControl.Which {
if service == sd.ServiceID {
notAuthorize = false
break
} else {
notAuthorize = true
}
}
if notAuthorize == true {
// sd.Err =
return
}
}
// AuthorizeWhen will authorize by ConnectionData.AccessControl.When
func (sd *StreamData) AuthorizeWhen() {}
// AuthorizeWhere will authorize by ConnectionData.AccessControl.Where
func (sd *StreamData) AuthorizeWhere() {
var notAuthorize bool
for _, ip := range sd.ConnectionData.AccessControl.Where {
// TODO : ip may contain zero padding!! org may restricted user to isp not subnet nor even device!!
if ip == sd.UIP.SourceIPAddress {
notAuthorize = false
break
} else {
notAuthorize = true
}
}
if notAuthorize == true {
// sd.Err =
return
}
}
|
package leetcode
import "sort"
func FourSum(nums []int, target int) [][]int {
var fourSum [][]int
sort.Ints(nums)
var len = len(nums)
if len <= 3 {
return nil
}
for i := 0; i < len; i++ {
if i > 0 && nums[i] == nums[i-1] {
continue
}
var target1 = target - nums[i]
for j := i + 1; j < len; j++ {
if j > i+1 && nums[j] == nums[j-1] {
continue
}
var target2 = target1 - nums[j]
l := j + 1
r := len - 1
for l < r {
var tempSum = nums[l] + nums[r]
if tempSum == target2 {
fourSum = append(fourSum, []int{nums[i], nums[j], nums[l], nums[r]})
l++
r--
for l < r && nums[l] == nums[l-1] {
l++
}
for l < r && nums[r] == nums[r+1] {
r--
}
} else if tempSum < target2 {
l++
} else {
r--
}
}
}
}
return fourSum
}
|
package _
import (
"bufio"
"flag"
"io/ioutil"
"log"
"os"
)
func main() {
// THE FLAGS FOR CRACKING
var intervalFlag = flag.Int("i", 1, "the inteval to go at")
var offsetFlag = flag.Int("o", 1024, "the offset to go at")
var wrapperFlag = flag.String("w", "", "the wrapper to read from")
var modeFlag = flag.String("b", "B", "the mode to run as")
flag.Parse()
INTERVAL := *intervalFlag
OFFSET := *offsetFlag
WRAPPERNAME := *wrapperFlag
MODE := *modeFlag
// fmt.Printf("INTERVAL %d OFFSET %d\n", INTERVAL, OFFSET)
SENTINEL := []byte{0x0, 0xff, 0x0, 0x0, 0xff, 0x0}
var err error
var data []byte
data, err = ioutil.ReadFile(WRAPPERNAME)
if err != nil {
log.Fatal("FAILED TO READ FILE")
}
if MODE == "B" {
output := RetrieveByteMode(data, SENTINEL, INTERVAL, OFFSET)
if output != nil {
f := bufio.NewWriter(os.Stdout)
defer f.Flush()
f.Write(output)
}
}
if MODE == "b" {
output := RetrieveBitMode(data, SENTINEL, INTERVAL, OFFSET)
if output != nil {
f := bufio.NewWriter(os.Stdout)
defer f.Flush()
f.Write(output)
}
}
}
func RetrieveBitMode(wrapper []byte, SENTINEL []byte, INTERVAL int, OFFSET int) []byte {
// i := 0
var b byte
poker := OFFSET
stopcounter := 0
output := make([]byte, 0)
for {
b = 0
if poker >= len(wrapper) {
break
}
for i := 0; i < 8; i++ {
if poker < len(wrapper) {
b = b | (wrapper[poker] & 0b0000001)
}
if i < 7 {
b = uint8(b << 1)
poker += INTERVAL
}
}
if b == SENTINEL[stopcounter] {
stopcounter++
} else {
stopcounter = 0
}
if stopcounter >= len(SENTINEL) {
return output
}
output = append(output, b)
poker += INTERVAL
}
return nil
}
func RetrieveByteMode(wrapper []byte, SENTINEL []byte, INTERVAL int, OFFSET int) []byte {
i := 0
poker := OFFSET
stopcounter := 0
// const SIZE = 1048576 // 2^20 b/c math.Pow is float aka not perfect
output := make([]byte, 0)
for {
if poker >= len(wrapper) {
break
}
b := wrapper[poker]
if b == SENTINEL[stopcounter] {
stopcounter++
} else {
stopcounter = 0
}
if stopcounter >= len(SENTINEL) {
return output
}
// break out
poker += INTERVAL
output = append(output, b)
i++
}
return nil
}
|
package acrel
import (
"fmt"
"testing"
)
func TestFrame_Copy(t *testing.T) {
a := &Frame{
Function: 0x84,
Data: nil,
}
fmt.Println(a)
b := a.Copy()
fmt.Println(b)
b.Function = 0x94
// a、b是独立的两块内存
fmt.Println(b)
fmt.Println(a)
}
|
package cache
const (
/*
*岗位
*/
KeyUserJob = "job::user:"
/*
*角色
*/
KeyUserRole = "role::user:"
/*
*菜单
*/
KeyUserMenu = "menu::user:"
/*
*部门
*/
KeyUserDept = "dept::user:"
/*
*数据
*/
KeyUserDataScope = "data::user:"
)
|
package main
import (
"fmt"
)
// https://leetcode-cn.com/problems/kth-smallest-element-in-a-bst/
// 230. 二叉搜索树中第K小的元素 | Kth Smallest Element in a BST
//------------------------------------------------------------------------------
func kthSmallest(root *TreeNode, k int) int {
if root == nil {
return 0
}
res := 0
var dfs func(node *TreeNode, k int) int
dfs = func(node *TreeNode, k int) int {
if node == nil {
return 0
}
cnt := dfs(node.Left, k)
if cnt >= k {
return cnt
}
if cnt++; cnt == k {
res = node.Val
return cnt
}
cnt += dfs(node.Right, k-cnt)
return cnt
}
dfs(root, k)
return res
}
func main() {
cases := [][]int{
{},
}
realCase := cases[0:]
for i, c := range realCase {
fmt.Println("## case", i)
// solve
fmt.Println(c)
}
}
|
package optionsgen_test
import (
"testing"
"time"
testcase "github.com/kazhuravlev/options-gen/options-gen/testdata/case-12-defaults-tag-02"
"github.com/stretchr/testify/assert"
)
func TestDefaultValues(t *testing.T) {
cases := []struct {
opts testcase.Options
wantError bool
}{
{
opts: testcase.NewOptions(),
wantError: false,
},
{
opts: testcase.NewOptions(testcase.WithPingPeriod(0)),
wantError: true,
},
{
opts: testcase.NewOptions(testcase.WithPingPeriod(time.Hour)),
wantError: true,
},
{
opts: testcase.NewOptions(testcase.WithName("")),
wantError: true,
},
{
opts: testcase.NewOptions(testcase.WithMaxAttempts(0)),
wantError: true,
},
{
opts: testcase.NewOptions(testcase.WithMaxAttempts(-1)),
wantError: true,
},
{
opts: testcase.NewOptions(testcase.WithMaxAttempts(11)),
wantError: true,
},
{
opts: testcase.NewOptions(testcase.WithEps(0.)),
wantError: true,
},
}
for _, tt := range cases {
t.Run("", func(t *testing.T) {
err := tt.opts.Validate()
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
}
|
package ratelimiter
import (
"errors"
"sync"
"time"
"code.cloudfoundry.org/lager"
"github.com/juju/ratelimit"
)
type Store interface {
Increment(string) (int, error)
Stats() map[string]int
}
type InMemoryStore struct {
bucketCapacity int
maxAmount int
validDuration time.Duration
expireDuration time.Duration
expireCheckInterval time.Duration
storage map[string]*entry
logger lager.Logger
sync.RWMutex
}
type entry struct {
bucket *ratelimit.Bucket
expiredAt time.Time
sync.RWMutex
}
func (e *entry) Expired() bool {
e.RLock()
defer e.RUnlock()
return time.Now().After(e.expiredAt)
}
func (e *entry) SetExpire(expiredAt time.Time) {
e.Lock()
defer e.Unlock()
e.expiredAt = expiredAt
}
func NewStore(bucketCapacity int, maxAmount int, validDuration time.Duration, expireDuration time.Duration, expireCheckInterval time.Duration, logger lager.Logger) Store {
store := &InMemoryStore{
bucketCapacity: bucketCapacity,
maxAmount: maxAmount,
validDuration: validDuration,
expireDuration: expireDuration,
expireCheckInterval: expireCheckInterval,
storage: make(map[string]*entry),
logger: logger,
}
store.expiryCycle()
return store
}
func newEntry(validDuration time.Duration, bucketCapacity int, maxAmount int) *entry {
return &entry{
bucket: ratelimit.NewBucketWithQuantum(validDuration, int64(bucketCapacity), int64(maxAmount)),
}
}
func (s *InMemoryStore) Increment(key string) (int, error) {
v, ok := s.get(key)
if !ok {
v = newEntry(s.validDuration, s.bucketCapacity, s.maxAmount)
}
v.SetExpire(time.Now().Add(s.expireDuration))
if avail := v.bucket.Available(); avail == 0 {
s.set(key, v)
return int(avail), errors.New("empty bucket")
}
v.bucket.Take(1)
s.set(key, v)
return int(v.bucket.Available()), nil
}
func (s *InMemoryStore) get(key string) (*entry, bool) {
s.RLock()
defer s.RUnlock()
v, ok := s.storage[key]
return v, ok
}
func (s *InMemoryStore) set(key string, value *entry) {
s.Lock()
defer s.Unlock()
s.storage[key] = value
}
func (s *InMemoryStore) expiryCycle() {
ticker := time.NewTicker(s.expireCheckInterval)
go func() {
for _ = range ticker.C {
s.Lock()
for k, v := range s.storage {
if v.Expired() {
s.logger.Info("removing-expired-key", lager.Data{"key": k})
delete(s.storage, k)
}
}
s.Unlock()
}
}()
}
func (s *InMemoryStore) Available(key string) int {
v, ok := s.get(key)
if !ok {
return 0
}
return int(v.bucket.Available())
}
func (s *InMemoryStore) Stats() map[string]int {
m := make(map[string]int)
s.Lock()
for k, v := range s.storage {
m[k] = int(v.bucket.Available())
}
s.Unlock()
return m
}
|
package loaders
import (
"context"
"time"
"github.com/syncromatics/kafmesh/internal/graph/loaders/generated"
"github.com/syncromatics/kafmesh/internal/graph/model"
"github.com/syncromatics/kafmesh/internal/graph/resolvers"
"github.com/pkg/errors"
)
//go:generate mockgen -source=./processorInputs.go -destination=./processorInputs_mock_test.go -package=loaders_test
// ProcessorInputRepository is the datastore repository for processor inputs
type ProcessorInputRepository interface {
ProcessorByInputs(context.Context, []int) ([]*model.Processor, error)
TopicByInputs(context.Context, []int) ([]*model.Topic, error)
}
var _ resolvers.ProcessorInputLoader = &ProcessorInputLoader{}
// ProcessorInputLoader contains data loaders for processor input relationships
type ProcessorInputLoader struct {
processorByInput *generated.ProcessorLoader
topicByInput *generated.TopicLoader
}
// NewProcessorInputLoader creates a new processor inputs loader
func NewProcessorInputLoader(ctx context.Context, repository ProcessorInputRepository, waitTime time.Duration) *ProcessorInputLoader {
loader := &ProcessorInputLoader{}
loader.processorByInput = generated.NewProcessorLoader(generated.ProcessorLoaderConfig{
Wait: waitTime,
MaxBatch: 100,
Fetch: func(keys []int) ([]*model.Processor, []error) {
r, err := repository.ProcessorByInputs(ctx, keys)
if err != nil {
return nil, []error{errors.Wrap(err, "failed to get processor from repository")}
}
return r, nil
},
})
loader.topicByInput = generated.NewTopicLoader(generated.TopicLoaderConfig{
Wait: waitTime,
MaxBatch: 100,
Fetch: func(keys []int) ([]*model.Topic, []error) {
r, err := repository.TopicByInputs(ctx, keys)
if err != nil {
return nil, []error{errors.Wrap(err, "failed to get topic from repository")}
}
return r, nil
},
})
return loader
}
// ProcessorByInput returns the processor for the input
func (l *ProcessorInputLoader) ProcessorByInput(inputID int) (*model.Processor, error) {
return l.processorByInput.Load(inputID)
}
// TopicByInput returns the topic for the input
func (l *ProcessorInputLoader) TopicByInput(inputID int) (*model.Topic, error) {
return l.topicByInput.Load(inputID)
}
|
package types
/*
Data Structure
key : address
value: map[time.Time]Data
*/
type Data struct {
raw_data []byte
meta []byte
}
|
package channels
import (
"math/rand"
"time"
)
func ping(pings chan<- int) {
for {
pings <- rand.Int()
time.Sleep(1 * time.Second)
}
}
func pong(pings <-chan int) {
for {
msg := <-pings
time.Sleep(1 * time.Second)
println(msg)
}
}
func TestChannels() {
pings := make(chan int, 1)
go ping(pings)
go pong(pings)
for {
time.Sleep(1 * time.Second)
}
}
|
package cain
import (
"encoding/xml"
"github.com/thought-machine/finance-messaging/iso20022"
)
type Document01300101 struct {
XMLName xml.Name `xml:"urn:iso:std:iso:20022:tech:xsd:cain.013.001.01 Document"`
Message *AcquirerRejection `xml:"AcqrrRjctn"`
}
func (d *Document01300101) AddMessage() *AcquirerRejection {
d.Message = new(AcquirerRejection)
return d.Message
}
// The AcquirerRejection message is sent by any party, to reject an Acquirer to Issuer message.
type AcquirerRejection struct {
// Information related to the protocol management.
Header *iso20022.Header19 `xml:"Hdr"`
// Information related to the reject.
Reject *iso20022.AcceptorRejection4 `xml:"Rjct"`
}
func (a *AcquirerRejection) AddHeader() *iso20022.Header19 {
a.Header = new(iso20022.Header19)
return a.Header
}
func (a *AcquirerRejection) AddReject() *iso20022.AcceptorRejection4 {
a.Reject = new(iso20022.AcceptorRejection4)
return a.Reject
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.