Create custom notes and occurrences

  import static 
  
 java.lang.Thread.sleep 
 ; 
 import 
  
 com.google.cloud.devtools.containeranalysis.v1. ContainerAnalysisClient 
 
 ; 
 import 
  
 io.grafeas.v1. GrafeasClient 
 
 ; 
 import 
  
 io.grafeas.v1. ListNoteOccurrencesRequest 
 
 ; 
 import 
  
 io.grafeas.v1. NoteName 
 
 ; 
 import 
  
 io.grafeas.v1. Occurrence 
 
 ; 
 import 
  
 java.io.IOException 
 ; 
 import 
  
 java.lang.InterruptedException 
 ; 
 public 
  
 class 
 OccurrencesForNote 
  
 { 
  
  
 // Retrieves all the Occurrences associated with a specified Note 
  
 // Here, all Occurrences are printed and counted 
  
 public 
  
 static 
  
 int 
  
 getOccurrencesForNote 
 ( 
 String 
  
 noteId 
 , 
  
 String 
  
 projectId 
 ) 
  
  
 throws 
  
 IOException 
 , 
  
 InterruptedException 
  
 { 
  
 // String noteId = "my-note"; 
  
 // String projectId = "my-project-id"; 
  
 final 
  
  NoteName 
 
  
 noteName 
  
 = 
  
  NoteName 
 
 . 
 of 
 ( 
 projectId 
 , 
  
 noteId 
 ); 
  
  ListNoteOccurrencesRequest 
 
  
 request 
  
 = 
  
  ListNoteOccurrencesRequest 
 
 . 
 newBuilder 
 () 
  
 . 
 setName 
 ( 
 noteName 
 . 
  toString 
 
 ()) 
  
 . 
 build 
 (); 
  
 // Initialize client that will be used to send requests. After completing all of your requests, 
  
 // call the "close" method on the client to safely clean up any remaining background resources. 
  
  GrafeasClient 
 
  
 client 
  
 = 
  
  ContainerAnalysisClient 
 
 . 
 create 
 (). 
  getGrafeasClient 
 
 (); 
  
 int 
  
 i 
  
 = 
  
 0 
 ; 
  
 for 
  
 ( 
  Occurrence 
 
  
 o 
  
 : 
  
 client 
 . 
  listNoteOccurrences 
 
 ( 
 request 
 ). 
 iterateAll 
 ()) 
  
 { 
  
 // Write custom code to process each Occurrence here 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 o 
 . 
 getName 
 ()); 
  
 i 
  
 = 
  
 i 
  
 + 
  
 1 
 ; 
  
 } 
  
 return 
  
 i 
 ; 
  
 } 
 } 
 

  import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 containeranalysis 
  
 "cloud.google.com/go/containeranalysis/apiv1" 
  
 "google.golang.org/api/iterator" 
  
 grafeaspb 
  
 "google.golang.org/genproto/googleapis/grafeas/v1" 
 ) 
 // getOccurrencesForNote retrieves all the Occurrences associated with a specified Note. 
 // Here, all Occurrences are printed and counted. 
 func 
  
 getOccurrencesForNote 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 noteID 
 , 
  
 projectID 
  
 string 
 ) 
  
 ( 
 int 
 , 
  
 error 
 ) 
  
 { 
  
 // noteID := fmt.Sprintf("my-note") 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 client 
 , 
  
 err 
  
 := 
  
 containeranalysis 
 . 
  NewClient 
 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 - 
 1 
 , 
  
 fmt 
 . 
 Errorf 
 ( 
 "NewClient: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 defer 
  
 client 
 . 
  Close 
 
 () 
  
 req 
  
 := 
  
& grafeaspb 
 . 
  ListNoteOccurrencesRequest 
 
 { 
  
 Name 
 : 
  
 fmt 
 . 
 Sprintf 
 ( 
 "projects/%s/notes/%s" 
 , 
  
 projectID 
 , 
  
 noteID 
 ), 
  
 } 
  
 it 
  
 := 
  
 client 
 . 
  GetGrafeasClient 
 
 (). 
 ListNoteOccurrences 
 ( 
 ctx 
 , 
  
 req 
 ) 
  
 count 
  
 := 
  
 0 
  
 for 
  
 { 
  
 occ 
 , 
  
 err 
  
 := 
  
 it 
 . 
 Next 
 () 
  
 if 
  
 err 
  
 == 
  
 iterator 
 . 
 Done 
  
 { 
  
 break 
  
 } 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 - 
 1 
 , 
  
 fmt 
 . 
 Errorf 
 ( 
 "occurrence iteration error: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 // Write custom code to process each Occurrence here. 
  
 fmt 
 . 
 Fprintln 
 ( 
 w 
 , 
  
 occ 
 ) 
  
 count 
  
 = 
  
 count 
  
 + 
  
 1 
  
 } 
  
 return 
  
 count 
 , 
  
 nil 
 } 
 

  /** 
 * TODO(developer): Uncomment these variables before running the sample 
 */ 
 // const projectId = 'your-project-id', // Your GCP Project ID 
 // const noteId = 'my-note-id' // Id of the note 
 // Import the library and create a client 
 const 
  
 { 
 ContainerAnalysisClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/containeranalysis 
' 
 ); 
 const 
  
 client 
  
 = 
  
 new 
  
  ContainerAnalysisClient 
 
 (); 
 // Get path to Note 
 const 
  
 formattedNote 
  
 = 
  
 client 
 . 
  notePath 
 
 ( 
 projectId 
 , 
  
 noteId 
 ); 
 // Retrieves all the Occurrences associated with a specified Note 
 const 
  
 [ 
 occurrences 
 ] 
  
 = 
  
 await 
  
 client 
 . 
  getGrafeasClient 
 
 (). 
 listNoteOccurrences 
 ({ 
  
 name 
 : 
  
 formattedNote 
 , 
 }); 
 if 
  
 ( 
 occurrences 
 . 
 length 
 ) 
  
 { 
  
 console 
 . 
 log 
 ( 
 'Occurrences:' 
 ); 
  
 occurrences 
 . 
 forEach 
 ( 
 occurrence 
  
 = 
>  
 { 
  
 console 
 . 
 log 
 ( 
 ` 
 ${ 
 occurrence 
 . 
 name 
 } 
 :` 
 ); 
  
 }); 
 } 
  
 else 
  
 { 
  
 console 
 . 
 log 
 ( 
 'No occurrences found.' 
 ); 
 } 
 

   
 # note_id    = "The identifier for the note to query" 
  
 # project_id = "The Google Cloud project ID of the occurrences to retrieve" 
  
 require 
  
 "google/cloud/container_analysis" 
  
 # Initialize the client 
  
 client 
  
 = 
  
 Google 
 :: 
 Cloud 
 :: 
  ContainerAnalysis 
 
 . 
  container_analysis 
 
 . 
  grafeas_client 
 
  
 name 
  
 = 
  
 client 
 . 
 note_path 
  
 project 
 : 
  
 project_id 
 , 
  
 note 
 : 
  
 note_id 
  
 count 
  
 = 
  
 0 
  
 client 
 . 
 list_note_occurrences 
 ( 
 name 
 : 
  
 name 
 ) 
 . 
 each 
  
 do 
  
 | 
 occurrence 
 | 
  
 # Process occurrence here 
  
 puts 
  
 occurrence 
  
 count 
  
 += 
  
 1 
  
 end 
  
 puts 
  
 "Found 
 #{ 
 count 
 } 
 occurrences" 
  
 count 
 end 
 def 
  
 get_discovery_info 
  
 resource_url 
 :, 
  
 project_id 
 : 
  
 # resource_url = "The URL of the resource associated with the occurrence." 
  
 #                # e.g. https://gcr.io/project/image@sha256:123 
  
 # project_id   = "The Google Cloud project ID of the occurrences to retrieve" 
  
 require 
  
 "google/cloud/container_analysis" 
  
 # Initialize the client 
  
 client 
  
 = 
  
 Google 
 :: 
 Cloud 
 :: 
  ContainerAnalysis 
 
 . 
  container_analysis 
 
 . 
  grafeas_client 
 
  
 parent 
  
 = 
  
 client 
 . 
 project_path 
  
 project 
 : 
  
 project_id 
  
 filter 
  
 = 
  
 "kind = 
 \" 
 DISCOVERY 
 \" 
 AND resourceUrl = 
 \" 
 #{ 
 resource_url 
 } 
 \" 
 " 
  
 client 
 . 
 list_occurrences 
 ( 
 parent 
 : 
  
 parent 
 , 
  
 filter 
 : 
  
 filter 
 ) 
 . 
 each 
  
 do 
  
 | 
 occurrence 
 | 
  
 # Process discovery occurrence here 
  
 puts 
  
 occurrence 
  
 end 
 end 
 def 
  
 occurrence_pubsub 
  
 subscription_id 
 :, 
  
 timeout_seconds 
 :, 
  
 project_id 
 : 
  
 # subscription_id = "A user-specified identifier for the new subscription" 
  
 # timeout_seconds = "The number of seconds to listen for new Pub/Sub messages" 
  
 # project_id      = "Your Google Cloud project ID" 
  
 require 
  
 "google/cloud/pubsub" 
  
 pubsub 
  
 = 
  
 Google 
 :: 
 Cloud 
 :: 
  PubSub 
 
 . 
  new 
 
  
 project_id 
 : 
  
 project_id 
  
 subscription_admin 
  
 = 
  
 pubsub 
 . 
  subscription_admin 
 
  
 subscription 
  
 = 
  
 subscription_admin 
 . 
 create_subscription 
  
 \ 
  
 name 
 : 
  
 pubsub 
 . 
 subscription_path 
 ( 
 subscription_id 
 ), 
  
 topic 
 : 
  
 pubsub 
 . 
 topic_path 
 ( 
 "container-analysis-occurrences-v1" 
 ) 
  
 subscriber 
  
 = 
  
 pubsub 
 . 
  subscriber 
 
  
 subscription 
 . 
 name 
  
 count 
  
 = 
  
 0 
  
 listener 
  
 = 
  
 subscriber 
 . 
  listen 
 
  
 do 
  
 | 
 received_message 
 | 
  
 count 
  
 += 
  
 1 
  
 # Process incoming occurrence here 
  
 puts 
  
 "Message 
 #{ 
 count 
 } 
 : 
 #{ 
 received_message 
 . 
 data 
 } 
 " 
  
 received_message 
 . 
  acknowledge! 
 
  
 end 
  
 listener 
 . 
  start 
 
  
 # Wait for incoming occurrences 
  
 sleep 
  
 timeout_seconds 
  
 listener 
 . 
 stop 
 . 
 wait! 
  
 subscription_admin 
 . 
 delete_subscription 
  
 subscription 
 : 
  
 subscription 
 . 
 name 
  
 # Print and return the total number of Pub/Sub messages received 
  
 puts 
  
 "Total Messages Received: 
 #{ 
 count 
 } 
 " 
  
 count 
 end 
 # rubocop:disable Metrics/MethodLength 
 def 
  
 poll_discovery_finished 
  
 resource_url 
 :, 
  
 timeout_seconds 
 :, 
  
 project_id 
 : 
  
 # resource_url    = "The URL of the resource associated with the occurrence." 
  
 #                   # e.g. https://gcr.io/project/image@sha256:123 
  
 # timeout_seconds = "The number of seconds to wait for the discovery occurrence" 
  
 # project_id      = "Your Google Cloud project ID" 
  
 require 
  
 "google/cloud/container_analysis" 
  
 deadline 
  
 = 
  
 Time 
 . 
 now 
  
 + 
  
 timeout_seconds 
  
 # Initialize the client 
  
 client 
  
 = 
  
 Google 
 :: 
 Cloud 
 :: 
  ContainerAnalysis 
 
 . 
  container_analysis 
 
 . 
  grafeas_client 
 
  
 parent 
  
 = 
  
 client 
 . 
 project_path 
  
 project 
 : 
  
 project_id 
  
 # Find the discovery occurrence using a filter string 
  
 discovery_occurrence 
  
 = 
  
 nil 
  
 while 
  
 discovery_occurrence 
 . 
 nil? 
  
 begin 
  
 filter 
  
 = 
  
 "resourceUrl= 
 \" 
 #{ 
 resource_url 
 } 
 \" 
 " 
  
 \ 
  
 'AND noteProjectId="goog-analysis" ' 
  
 \ 
  
 'AND noteId="PACKAGE_VULNERABILITY"' 
  
 # The above filter isn't testable, since it looks for occurrences in a 
  
 # locked down project. Fall back to a more permissive filter for testing 
  
 filter 
  
 = 
  
 "kind = 
 \" 
 DISCOVERY 
 \" 
 AND resourceUrl = 
 \" 
 #{ 
 resource_url 
 } 
 \" 
 " 
  
 # Only the discovery occurrence should be returned for the given filter 
  
 discovery_occurrence 
  
 = 
  
 client 
 . 
 list_occurrences 
 ( 
 parent 
 : 
  
 parent 
 , 
  
 filter 
 : 
  
 filter 
 ) 
 . 
 first 
  
 rescue 
  
 StandardError 
  
 # If there is an error, keep trying until the deadline 
  
 puts 
  
 "discovery occurrence not yet found" 
  
 ensure 
  
 # check for timeout 
  
 sleep 
  
 1 
  
 raise 
  
 "Timeout while retrieving discovery occurrence." 
  
 if 
  
 Time 
 . 
 now 
 > 
 deadline 
  
 end 
  
 end 
  
 # Wait for the discovery occurrence to enter a terminal state 
  
 status 
  
 = 
  
 Grafeas 
 :: 
  V1 
 
 :: 
 DiscoveryOccurrence 
 :: 
 AnalysisStatus 
 :: 
 PENDING 
  
 until 
  
 [ 
 :FINISHED_SUCCESS 
 , 
  
 :FINISHED_FAILED 
 , 
  
 :FINISHED_UNSUPPORTED 
 ]. 
 include? 
  
 status 
  
 # Update occurrence 
  
 begin 
  
 updated 
  
 = 
  
 client 
 . 
 get_occurrence 
  
 name 
 : 
  
 discovery_occurrence 
 . 
 name 
  
 status 
  
 = 
  
 updated 
 . 
 discovery 
 . 
 analysis_status 
  
 rescue 
  
 StandardError 
  
 # If there is an error, keep trying until the deadline 
  
 puts 
  
 "discovery occurrence not yet in terminal state" 
  
 ensure 
  
 # check for timeout 
  
 sleep 
  
 1 
  
 raise 
  
 "Timeout while retrieving discovery occurrence." 
  
 if 
  
 Time 
 . 
 now 
 > 
 deadline 
  
 end 
  
 end 
  
 puts 
  
 "Found discovery occurrence 
 #{ 
 updated 
 . 
 name 
 } 
 ." 
  
 puts 
  
 "Status: 
 #{ 
 updated 
 . 
 discovery 
 . 
 analysis_status 
 } 
 " 
  
 updated 
 end 
 # rubocop:enable Metrics/MethodLength 
 def 
  
 find_vulnerabilities_for_image 
  
 resource_url 
 :, 
  
 project_id 
 : 
  
 # resource_url = "The URL of the resource associated with the occurrence 
  
 #                e.g. https://gcr.io/project/image@sha256:123" 
  
 # project_id   = "The Google Cloud project ID of the vulnerabilities to find" 
  
 require 
  
 "google/cloud/container_analysis" 
  
 # Initialize the client 
  
 client 
  
 = 
  
 Google 
 :: 
 Cloud 
 :: 
  ContainerAnalysis 
 
 . 
  container_analysis 
 
 . 
  grafeas_client 
 
  
 parent 
  
 = 
  
 client 
 . 
 project_path 
  
 project 
 : 
  
 project_id 
  
 filter 
  
 = 
  
 "resourceUrl = 
 \" 
 #{ 
 resource_url 
 } 
 \" 
 AND kind = 
 \" 
 VULNERABILITY 
 \" 
 " 
  
 client 
 . 
 list_occurrences 
  
 parent 
 : 
  
 parent 
 , 
  
 filter 
 : 
  
 filter 
 end 
 def 
  
 find_high_severity_vulnerabilities_for_image 
  
 resource_url 
 :, 
  
 project_id 
 : 
  
 # resource_url       = "The URL of the resource associated with the occurrence." 
  
 #                      # If you are using Google Container Registry 
  
 #                      # e.g. https://gcr.io/project/repo/image@sha256:123 
  
 #                      # If you are using Google Artifact Registry 
  
 #                      # e.g. https://LOCATION-docker.pkg.dev/project/repo/image@sha256:123 
  
 # project_id   = "The Google Cloud project ID of the vulnerabilities to find" 
  
 require 
  
 "google/cloud/container_analysis" 
  
 # Initialize the client 
  
 client 
  
 = 
  
 Google 
 :: 
 Cloud 
 :: 
  ContainerAnalysis 
 
 . 
  container_analysis 
 
 . 
  grafeas_client 
 
  
 parent 
  
 = 
  
 client 
 . 
 project_path 
  
 project 
 : 
  
 project_id 
  
 filter 
  
 = 
  
 "resourceUrl = 
 \" 
 #{ 
 resource_url 
 } 
 \" 
 AND kind = 
 \" 
 VULNERABILITY 
 \" 
 " 
  
 vulnerability_list 
  
 = 
  
 client 
 . 
 list_occurrences 
  
 parent 
 : 
  
 parent 
 , 
  
 filter 
 : 
  
 filter 
  
 # Filter the list to include only "high" and "critical" vulnerabilities 
  
 vulnerability_list 
 . 
 select 
  
 do 
  
 | 
 item 
 | 
  
 [ 
 :HIGH 
 , 
  
 :CRITICAL 
 ]. 
 include? 
  
 item 
 . 
 vulnerability 
 . 
 effective_severity 
  
 end 
 end 
 

  from 
  
 google.cloud.devtools 
  
 import 
  containeranalysis_v1 
 
 def 
  
 get_occurrences_for_note 
 ( 
 note_id 
 : 
 str 
 , 
 project_id 
 : 
 str 
 ) 
 - 
> int 
 : 
  
 """Retrieves all the occurrences associated with a specified Note. 
 Here, all occurrences are printed and counted.""" 
 # note_id = 'my-note' 
 # project_id = 'my-gcp-project' 
 client 
 = 
  containeranalysis_v1 
 
 . 
  ContainerAnalysisClient 
 
 () 
 grafeas_client 
 = 
 client 
 . 
 get_grafeas_client 
 () 
 note_name 
 = 
 f 
 "projects/ 
 { 
 project_id 
 } 
 /notes/ 
 { 
 note_id 
 } 
 " 
 response 
 = 
 grafeas_client 
 . 
 list_note_occurrences 
 ( 
 name 
 = 
 note_name 
 ) 
 count 
 = 
 0 
 for 
 o 
 in 
 response 
 : 
 # do something with the retrieved occurrence 
 # in this sample, we will simply count each one 
 count 
 += 
 1 
 return 
 count