public loadSecurityGroupsByApplicationName(applicationName: string): IPromise<ISecurityGroup[]> {
    return SearchService.search<ISecurityGroupSearchResult>({
      q: applicationName,
      type: 'securityGroups',
      pageSize: 1000,
    }).then((searchResults: ISearchResults<ISecurityGroupSearchResult>) => {
      let result: ISecurityGroup[] = [];
      if (!searchResults || !searchResults.results) {
        this.$log.warn('WARNING: Gate firewall endpoint appears to be down.');
      } else {
        result = filter(searchResults.results, { application: applicationName });
      }

      return result;
    });
  }

 public listHealthChecks (type?: string): ng.IPromise<IGceHealthCheck[]> {
   if (type) {
     return this.listHealthChecks().then(healthChecks => healthChecks.filter(healthCheck => healthCheck.healthCheckType === type));
   } else {
     return this.searchService
       .search({q: '', type: 'healthChecks'}, this.infrastructureCaches.get('healthChecks'))
       .then((searchResults: ISearchResults<IHealthCheckSearchResults>) => {
         if (searchResults && searchResults.results) {
           const healthChecks = searchResults.results.filter(result => result.provider === 'gce')
             .map(result => {
               const healthCheck = JSON.parse(result.healthCheck) as IGceHealthCheck;
               healthCheck.account = result.account;
               return healthCheck;
             });
           return uniqWith(healthChecks, (checkA: IGceHealthCheck, checkB: IGceHealthCheck) => {
             return checkA.name === checkB.name && checkA.healthCheckType === checkB.healthCheckType &&
                 checkA.account === checkB.account;
           });
         } else {
           return [];
         }
       })
       .catch(() => []);
   }
 }

 public listCertificates(): IPromise<IGceCertificate[]> {
   return this.searchService
     .search<IGceCertificate>({q: '', type: 'sslCertificates'}, this.infrastructureCaches.get('certificates'))
     .then((searchResults: ISearchResults<IGceCertificate>) => {
       if (searchResults && searchResults.results) {
         return searchResults.results.filter(certificate => certificate.provider === 'gce');
       } else {
         return [];
       }
     })
     .catch(() => []);
 }

 public listAddresses(region?: string): IPromise<IGceAddress[]> {
   if (region) {
     return this.listAddresses(null /* region */).then(addresses => addresses.filter(address => address.region === region));
   } else {
     return this.searchService
       .search<IAddressSearchResults>({q: '', type: 'addresses'}, this.infrastructureCaches.get('addresses'))
       .then((searchResults: ISearchResults<IAddressSearchResults>) => {
         if (searchResults && searchResults.results) {
           return searchResults.results
             .filter(result => result.provider === 'gce')
             .map(result => {
               const address = JSON.parse(result.address) as IGceAddress;
               address.account = result.account;
               address.region = result.region;
               return address;
             });
         } else {
           return [];
         }
       })
       .catch(() => []);
   }
 }