Releasing version 65.101.0

Releasing version 65.101.0

Author: oci-dex-release-bot

CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 
+## 65.101.0 - 2025-09-23
+### Added 
+- Support for calling Oracle Cloud Infrastructure services in the me-ibri-1 region 
+- Support for Resource Analytics service 
+- Support for Oracle MultiCloud service  
+- Support for standalone Java Development Kit (JDK) scanning and usage tracking using shared external volumes in the Java Management service 
+- Support for enhanced Java library detection and Software Bill of Materials (SBOM) generation in the Java Management Service 
+- Support for dynamic Java library scanning in the Java Management service 
+- Support for vulnerability scanning using Application Dependency Management (ADM) and confidence level scoring in the Java Management service 
+- Support for Java runtime discovery and tracking in Kubernetes environments in the Java Management service 
+- Support for detecting, installing, and reporting Oracle Enterprise Performance Pack releases in the Java Management service 
+- Support for task scheduling for scans and lifecycle operations in the Java Management service 
+- Support for capturing and displaying managed instance IP addresses and hostnames in the Java Management service 
+- Support for selecting multiple applications and target Java Development Kits (JDKs) during Java migration analysis in the Java Management service 
+- Support for subscription acknowledgment in the Java Management service 
+- Support for analyzing application artifacts in the Java Management service 
+- Support for querying work requests independently from fleets in applications in the Java Management service  
+- Support for custom report generation with advanced filters in the Java Management service 
+- Support for configuring exascale storage on dedicated infrastructure (Exacs) in the Database service  
+- Support for listing marketplace metadata public keys in the Marketplace service 
+- Support for external attested metadata creation in the Marketplace service 
+- Support for discovery endpoint for shared clusters in the OCI Cache service     
+
+### Breaking Changes 
+- The type of `PricingTypes` has been changed from `ListingSummaryPricingTypesEnum` to `PricingTypeEnumEnum` in the model `ListingSummary` in the marketplace service
+
 ## 65.100.1 - 2025-09-16
 ### Added 
 - Support for AI Data Platform service 

Makefile

@@ -1,6 +1,6 @@
 DOC_SERVER_URL=https:\/\/docs.oracle.com
 
-GEN_TARGETS = identity core objectstorage loadbalancer database audit dns filestorage email containerengine resourcesearch keymanagement announcementsservice healthchecks waas autoscaling streaming ons monitoring resourcemanager budget workrequests functions limits events oce oda analytics integration marketplace apigateway datacatalog dataflow datascience nosql secrets vault bds cims datasafe mysql dataintegration ocvp usageapi blockchain loggingingestion logging loganalytics managementdashboard sch loggingsearch managementagent cloudguard opsi computeinstanceagent optimizer tenantmanagercontrolplane rover databasemanagement artifacts apmsynthetics goldengate apmcontrolplane apmtraces networkloadbalancer vulnerabilityscanning databasemigration servicecatalog ailanguage operatoraccesscontrol bastion genericartifactscontent jms devops datalabelingservice datalabelingservicedataplane apmconfig waf certificates certificatesmanagement usage databasetools servicemanagerproxy appmgmtcontrol ospgateway identitydataplane visualbuilder osubusage osubsubscription osuborganizationsubscription osubbillingschedule dashboardservice threatintelligence aivision aispeech stackmonitoring adm licensemanager onesubscription governancerulescontrolplane waa networkfirewall vnmonitoring emwarehouse lockbox fusionapps mediaservices opa opensearch cloudmigrations cloudbridge disasterrecovery containerinstances aidocument queue recovery vbsinst identitydomains accessgovernancecp ocicontrolcenter osmanagementhub fleetsoftwareupdate computecloudatcustomer marketplacepublisher redis jmsjavadownloads psql generativeai generativeaiinference capacitymanagement globallydistributeddatabase desktops emaildataplane clusterplacementgroups marketplaceprivateoffer resourcescheduler demandsignal fleetappsmanagement delegateaccesscontrol generativeaiagent generativeaiagentruntime securityattribute zpr dblm mngdmac lustrefilestorage modeldeployment distributeddatabase apiaccesscontrol wlms dbmulticloud apiplatform multicloud managedkafka aidataplatform ##SPECNAME##
+GEN_TARGETS = identity core objectstorage loadbalancer database audit dns filestorage email containerengine resourcesearch keymanagement announcementsservice healthchecks waas autoscaling streaming ons monitoring resourcemanager budget workrequests functions limits events oce oda analytics integration marketplace apigateway datacatalog dataflow datascience nosql secrets vault bds cims datasafe mysql dataintegration ocvp usageapi blockchain loggingingestion logging loganalytics managementdashboard sch loggingsearch managementagent cloudguard opsi computeinstanceagent optimizer tenantmanagercontrolplane rover databasemanagement artifacts apmsynthetics goldengate apmcontrolplane apmtraces networkloadbalancer vulnerabilityscanning databasemigration servicecatalog ailanguage operatoraccesscontrol bastion genericartifactscontent jms devops datalabelingservice datalabelingservicedataplane apmconfig waf certificates certificatesmanagement usage databasetools servicemanagerproxy appmgmtcontrol ospgateway identitydataplane visualbuilder osubusage osubsubscription osuborganizationsubscription osubbillingschedule dashboardservice threatintelligence aivision aispeech stackmonitoring adm licensemanager onesubscription governancerulescontrolplane waa networkfirewall vnmonitoring emwarehouse lockbox fusionapps mediaservices opa opensearch cloudmigrations cloudbridge disasterrecovery containerinstances aidocument queue recovery vbsinst identitydomains accessgovernancecp ocicontrolcenter osmanagementhub fleetsoftwareupdate computecloudatcustomer marketplacepublisher redis jmsjavadownloads psql generativeai generativeaiinference capacitymanagement globallydistributeddatabase desktops emaildataplane clusterplacementgroups marketplaceprivateoffer resourcescheduler demandsignal fleetappsmanagement delegateaccesscontrol generativeaiagent generativeaiagentruntime securityattribute zpr dblm mngdmac lustrefilestorage modeldeployment distributeddatabase apiaccesscontrol wlms dbmulticloud apiplatform managedkafka aidataplatform multicloud resourceanalytics jmsutils ##SPECNAME##
 NON_GEN_TARGETS = common common/auth objectstorage/transfer example
 TARGETS = $(NON_GEN_TARGETS) $(GEN_TARGETS)
 

common/common.go

@@ -12,6 +12,7 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -53,9 +54,18 @@ var getRegionInfoFromInstanceMetadataService = getRegionInfoFromInstanceMetadata
 // OciRealmSpecificServiceEndpointTemplateEnabled is the flag to enable the realm specific service endpoint template. This one has higher priority than the environment variable.
 var OciRealmSpecificServiceEndpointTemplateEnabled *bool = nil
 
+// reNonWord precomiles the regex once at the package scope
+var reNonWord = regexp.MustCompile(`[^\w]`)
+
 // OciSdkEnabledServicesMap is a list of services that are enabled, default is an empty list which means all services are enabled
 var OciSdkEnabledServicesMap map[string]bool
 
+// OciSdkEnabledServicesOnce is a sync.Once variable to ensure the OciSdkEnabledServicesMap is initialized only once
+var OciSdkEnabledServicesOnce sync.Once
+
+// OciSdkEnabledServicesMu is a mutex to protect access to the OciSdkEnabledServicesMap
+var OciSdkEnabledServicesMu sync.RWMutex
+
 // OciDeveloperToolConfigurationFilePathEnvVar is the environment variable name for the OCI Developer Tool Config File Path
 const OciDeveloperToolConfigurationFilePathEnvVar = "OCI_DEVELOPER_TOOL_CONFIGURATION_FILE_PATH"
 
@@ -585,32 +595,48 @@ func getOciSdkEnabledServicesMap() map[string]bool {
 
 // AddServiceToEnabledServicesMap adds the service to the enabledServiceMap
 // The service name will auto transit to lower case and remove all the non-word characters.
+// Concurrency (goroutine-safe). The map is initialized with sync.Once, and writes are protected by a RWMutex.
 func AddServiceToEnabledServicesMap(serviceName string) {
-	if OciSdkEnabledServicesMap == nil {
-		OciSdkEnabledServicesMap = make(map[string]bool)
-	}
-	re, _ := regexp.Compile(`[^\w]`)
+	OciSdkEnabledServicesOnce.Do(func() {
+		OciSdkEnabledServicesMap = getOciSdkEnabledServicesMap()
+		if OciSdkEnabledServicesMap == nil {
+			OciSdkEnabledServicesMap = make(map[string]bool)
+		}
+	})
 	serviceName = strings.ToLower(serviceName)
-	serviceName = re.ReplaceAllString(serviceName, "")
+	serviceName = reNonWord.ReplaceAllString(serviceName, "")
+
+	OciSdkEnabledServicesMu.Lock()
+	defer OciSdkEnabledServicesMu.Unlock()
 	OciSdkEnabledServicesMap[serviceName] = true
 }
 
 // CheckForEnabledServices checks if the service is enabled in the enabledServiceMap.
 // It will first check if the map is initialized, if not, it will initialize the map.
 // If the map is empty, it means all the services are enabled.
 // If the map is not empty, it means only the services in the map and value is true are enabled.
+// Concurrency (goroutine-safe). Initialization uses sync.Once and reads are protected by a RWMutex.
 func CheckForEnabledServices(serviceName string) bool {
-	if OciSdkEnabledServicesMap == nil {
+	OciSdkEnabledServicesOnce.Do(func() {
 		OciSdkEnabledServicesMap = getOciSdkEnabledServicesMap()
-	}
+		if OciSdkEnabledServicesMap == nil {
+			OciSdkEnabledServicesMap = make(map[string]bool)
+		}
+	})
 	serviceName = strings.ToLower(serviceName)
+	serviceName = reNonWord.ReplaceAllString(serviceName, "")
+
+	OciSdkEnabledServicesMu.RLock()
+	defer OciSdkEnabledServicesMu.RUnlock()
+
 	if len(OciSdkEnabledServicesMap) == 0 {
 		return true
 	}
-	if _, ok := OciSdkEnabledServicesMap[serviceName]; !ok {
+	allowed, ok := OciSdkEnabledServicesMap[serviceName]
+	if !ok {
 		return false
 	}
-	return OciSdkEnabledServicesMap[serviceName]
+	return allowed
 }
 
 // CheckAllowOnlyDeveloperToolConfigurationRegions checks if only developer tool configuration regions are allowed

common/common_test.go

@@ -11,6 +11,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -649,3 +650,51 @@ func TestGetRealmIDFromRegion(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, "oc0", realmID)
 }
+
+// TestCheckForEnabledServices_Race tests the CheckForEnabledServices function for race conditions.
+// Relies on -race flag to fail:
+//
+//	go test -race ./common -run TestCheckForEnabledServices_Race
+func TestCheckForEnabledServices_Race(t *testing.T) {
+	OciSdkEnabledServicesOnce = sync.Once{}
+	OciSdkEnabledServicesMap = nil
+
+	const goroutines = 200
+	var wg sync.WaitGroup
+	wg.Add(goroutines)
+
+	for i := 0; i < goroutines; i++ {
+		go func() {
+			defer wg.Done()
+			_ = CheckForEnabledServices("objectstorage")
+		}()
+	}
+
+	wg.Wait()
+}
+
+// TestAddAndCheckEnabledServices_Concurrent tests concurrent reads & writes on the same map.
+// Test with -race flag:
+//
+//	go test -race ./common -run TestAddAndCheckEnabledServices_Concurrent
+func TestAddAndCheckEnabledServices_Concurrent(t *testing.T) {
+	OciSdkEnabledServicesOnce = sync.Once{}
+	OciSdkEnabledServicesMap = nil
+
+	const pairs = 100
+	var wg sync.WaitGroup
+	wg.Add(pairs * 2) // two goroutines per pair
+
+	for i := 0; i < pairs; i++ {
+		go func() {
+			defer wg.Done()
+			AddServiceToEnabledServicesMap("objectstorage")
+		}()
+		go func() {
+			defer wg.Done()
+			_ = CheckForEnabledServices("objectstorage")
+		}()
+	}
+
+	wg.Wait()
+}

common/http.go

@@ -24,6 +24,8 @@ const (
 	UsingExpectHeaderEnvVar = "OCI_GOSDK_USING_EXPECT_HEADER"
 	//EncodePathParamsEnvVar determines if special characters in path params such as / and & are URL encoded
 	EncodePathParamsEnvVar = "OCI_GOSDK_ENCODE_PATH_PARAMS"
+	// EscapeJSONToASCIIEnvVar determines if non-ASCII characters in JSON strings are escaped
+	EscapeJSONToASCIIEnvVar = "OCI_GOSDK_ESCAPE_JSON_ASCII"
 )
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -257,6 +259,49 @@ func removeNilFieldsInJSONWithTaggedStruct(rawJSON []byte, value reflect.Value)
 	return json.Marshal(fixedMap)
 }
 
+// escapeJSONToASCII takes a JSON payload and returns an equivalent JSON where all string values are escaped to ASCII
+func escapeJSONToASCII(rawJSON []byte) ([]byte, error) {
+	var rawInterface interface{}
+	decoder := json.NewDecoder(bytes.NewReader(rawJSON))
+	decoder.UseNumber()
+	if err := decoder.Decode(&rawInterface); err != nil {
+		return nil, err
+	}
+
+	// transform recursively visits the JSON value:
+	// 		- For objects (map[string[interface{}]]), recurse on each value
+	// 		- For arrays ([]interface{}), recurse on each element
+	// 		- For strings, produce a JSON-quoted ASCII-only representation
+	// 		- For other types, return as is
+	var transform func(interface{}) interface{}
+	transform = func(x interface{}) interface{} {
+		switch t := x.(type) {
+		case map[string]interface{}:
+			m := make(map[string]interface{}, len(t))
+			for key, val := range t {
+				m[key] = transform(val)
+			}
+			return m
+		case []interface{}:
+			s := make([]interface{}, len(t))
+			for i, val := range t {
+				s[i] = transform(val)
+			}
+			return s
+		case string:
+			// QuoteToASCII returns a 'quoted' JSON string containing only ASCII characters
+			// ex: input: "ハッピー" -> "\"\\u30cf\\u30c3\\u30d4\\u30fc\""
+			// Returns as json.RawMessage so it gets embedded directly
+			q := strconv.AppendQuoteToASCII(nil, t)
+			return json.RawMessage(q)
+		default:
+			return x
+		}
+	}
+
+	return json.Marshal(transform(rawInterface))
+}
+
 func addToBody(request *http.Request, value reflect.Value, field reflect.StructField, binaryBodySpecified *bool) (e error) {
 	Debugln("Marshaling to body from field:", field.Name)
 	if request.Body != nil {
@@ -279,6 +324,13 @@ func addToBody(request *http.Request, value reflect.Value, field reflect.StructF
 		return
 	}
 
+	if IsEnvVarTrue(EscapeJSONToASCIIEnvVar) {
+		marshaled, e = escapeJSONToASCII(marshaled)
+		if e != nil {
+			return
+		}
+	}
+
 	if defaultLogger.LogLevel() == verboseLogging {
 		Debugf("Marshaled body is: %s\n", string(marshaled))
 	}

common/http_test.go

@@ -1622,3 +1622,76 @@ func TestRemoveNilWithInt64Values(t *testing.T) {
 	assert.True(t, strings.Contains(string(jsonRet), "9223372036854775807"))
 	assert.Equal(t, int64(9223372036854775807), *ss.Data)
 }
+
+func TestEscapeJSONToASCII_Strings(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "Strings",
+			input:    `"hello, 世界"`,
+			expected: `"hello, \u4e16\u754c"`,
+		},
+		{
+			name:     "String Array",
+			input:    `["こんにちは", "hello, world", "hola, señor"]`,
+			expected: `["\u3053\u3093\u306b\u3061\u306f","hello, world","hola, se\u00f1or"]`,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := escapeJSONToASCII([]byte(tc.input))
+			assert.NoError(t, err)
+			assert.Equal(t, tc.expected, string(result))
+		})
+	}
+}
+func TestEscapeJSONToASCII_Interfaces(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "String Map Interface",
+			input:    `{"greeting": "bonjour, ça va?", "farewell": "adiós", "welcome": "ようこそ"}`,
+			expected: `{"welcome":"\u3088\u3046\u3053\u305d","greeting":"bonjour, \u00e7a va?","farewell":"adi\u00f3s"}`,
+		},
+		{
+			name: "Deep Nested Interface",
+			input: `{
+						  "a": {
+							  "b": [null, {
+								  "c": ["cómo estás", {"d": "ハッピー"}],
+								  "n": 42,
+								  "ok": true
+							  }],
+						  	  "jp": "良い一日を"
+						  },
+						  "keep": "okay"
+					  }`,
+			expected: `{
+						"keep": "okay",
+						"a": {
+							"jp": "\u826f\u3044\u4e00\u65e5\u3092",
+							"b": [null, {
+								"c": ["c\u00f3mo est\u00e1s", {"d": "\u30cf\u30c3\u30d4\u30fc"}],
+									"n": 42,
+									"ok": true
+								}]
+						}
+					}`,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := escapeJSONToASCII([]byte(tc.input))
+			assert.NoError(t, err)
+			assert.JSONEq(t, tc.expected, string(result))
+		})
+	}
+}