This code is a set of functions for interacting with Google Cloud's Compute Engine API, using the google-auth-library and googleapis libraries to authenticate and make requests to the API. The functions, including listUrlMaps, listTargetProxies, and listGlobalForwards, follow a common pattern to retrieve metadata from the API and return promises that resolve to objects with the desired data.

Run example

npm run import -- "list google bucket url map"

list google bucket url map

var path = require('path');
var importer = require('../Core');
var authorizeGoogle = importer.import("authorize google service");

function listUrlMaps(project, urlMap) {
    var params = {};
    if(urlMap) {
        params.filter = `name="${urlMap}"`
    }
    return authorizeGoogle()
        .then(client => client.request({
            url: `https://www.googleapis.com/compute/v1/projects/${project}/global/urlMaps`,
            params
        }))
        .then(res => {
            return (res.data.items || []).reduce((obj, cur) => {
                obj[cur.name] = {
                    hostRules: cur.hostRules,
                    pathMatchers: cur.pathMatchers,
                    fingerprint: cur.fingerprint
//    defaultService: 'https://www.googleapis.com/compute/v1/projects/spahaha-ea443/global/backendServices/web-map-backend-service',
                };
                return obj;
            }, {})
        });
}

function listTargetProxies(project, urlMap) {
    var params = {};
    if(urlMap) {
        params.filter = `urlMap="https://www.googleapis.com/compute/v1/projects/${project}/global/urlMaps/${urlMap}"`
    }
    return authorizeGoogle()
        .then(client => client.request({
            url: `https://www.googleapis.com/compute/v1/projects/${project}/global/targetHttpsProxies`,
            params
        }))
        .then(res => (res.data.items || []).reduce((obj, p) => {
            obj[p.name] = p.sslCertificates;
            return obj
        }, {}));
}

function listGlobalForwards(project, proxy, ip) {
    var params = {};
    if(proxy) {
        params['filter'] = `target="https://www.googleapis.com/compute/v1/projects/${project}/global/targetHttpsProxies/${proxy}"`
    }
    if(ip) {
        params['filter'] = `IPAddress="https://www.googleapis.com/compute/v1/projects/${project}/global/addresses/${ip}"`;
    }
    return authorizeGoogle()
        .then(client => client.request({
            url: `https://www.googleapis.com/compute/v1/projects/${project}/global/forwardingRules`,
            params
        }))
        .then(res => {
            return (res.data.items || []).reduce((obj, cur) => {
                obj[cur.name] = {
                    IPAddress: cur.IPAddress,
                    target: cur.target
                }
                return obj;
            }, {})
        });
}

function listBackendBuckets(project, bucketName) {
    var params = {};
    if(bucketName) {
        params.filter = `bucketName="${bucketName}"`;
    }
    return authorizeGoogle()
        .then(client => client.request({
            url: `https://www.googleapis.com/compute/v1/projects/${project}/global/backendBuckets`,
            params
        }))
        .then(res => {
            return (res.data.items || []).reduce((obj, cur) => {
                obj[cur.name] = cur.bucketName;
                return obj;
            }, {})
        });
}

function listSslCertificates(project, certName) {
    var params = {};
    if(certName) {
        params.filter = `name="${certName}"`;
    }
    return authorizeGoogle()
        .then(client => client.request({
            url: `https://www.googleapis.com/compute/v1/projects/${project}/global/sslCertificates`,
            params
        }))
        .then(res => {
            return (res.data.items || []).reduce((obj, cur) => {
                obj[cur.name] = cur.description;
                return obj;
            }, {})
        });
}

module.exports = {
    listUrlMaps,
    listTargetProxies,
    listGlobalForwards,
    listBackendBuckets,
    listSslCertificates
};

```javascript
const { google } = require('googleapis');

const authorizeGoogle = async () => {
  const auth = new google.auth.GoogleAuth({
    // TODO: Replace with service account credentials
    // For more information, see: https://developers.google.com/identity/protocols/oauth2/service-account
  });
  const client = await auth.getClient();
  return client.authorize();
};

const compute = async (auth) => {
  return google.compute('v1').authorize(auth);
};

const makeRequest = async (auth, url, params = {}) => {
  const compute = await compute(auth);
  const res = await compute.projects().global.get(url, { params });
  return res.data;
};

const listUrlMaps = async (project, urlMap) => {
  const url = `https://www.googleapis.com/compute/v1/projects/${project}/global/urlMaps`;
  const params = urlMap? { filter: `name="${urlMap}"` } : {};
  const res = await makeRequest(await authorizeGoogle(), url, params);
  return (res.items || []).reduce((obj, cur) => {
    obj[cur.name] = {
      hostRules: cur.hostRules,
      pathMatchers: cur.pathMatchers,
      fingerprint: cur.fingerprint,
    };
    return obj;
  }, {});
};

const listTargetProxies = async (project, urlMap) => {
  const url = `https://www.googleapis.com/compute/v1/projects/${project}/global/targetHttpsProxies`;
  const params = urlMap? { filter: `urlMap="https://www.googleapis.com/compute/v1/projects/${project}/global/urlMaps/${urlMap}"` } : {};
  const res = await makeRequest(await authorizeGoogle(), url, params);
  return (res.items || []).reduce((obj, p) => {
    obj[p.name] = p.sslCertificates;
    return obj;
  }, {});
};

const listGlobalForwards = async (project, proxy, ip) => {
  const url = `https://www.googleapis.com/compute/v1/projects/${project}/global/forwardingRules`;
  const params = proxy? { filter: `target="https://www.googleapis.com/compute/v1/projects/${project}/global/targetHttpsProxies/${proxy}"` } : {};
  if (ip) {
    params.filter = `IPAddress="https://www.googleapis.com/compute/v1/projects/${project}/global/addresses/${ip}"`;
  }
  const res = await makeRequest(await authorizeGoogle(), url, params);
  return (res.items || []).reduce((obj, cur) => {
    obj[cur.name] = {
      IPAddress: cur.IPAddress,
      target: cur.target,
    };
    return obj;
  }, {});
};

const listBackendBuckets = async (project, bucketName) => {
  const url = `https://www.googleapis.com/compute/v1/projects/${project}/global/backendBuckets`;
  const params = bucketName? { filter: `bucketName="${bucketName}"` } : {};
  const res = await makeRequest(await authorizeGoogle(), url, params);
  return (res.items || []).reduce((obj, cur) => {
    obj[cur.name] = cur.bucketName;
    return obj;
  }, {});
};

const listSslCertificates = async (project, certName) => {
  const url = `https://www.googleapis.com/compute/v1/projects/${project}/global/sslCertificates`;
  const params = certName? { filter: `name="${certName}"` } : {};
  const res = await makeRequest(await authorizeGoogle(), url, params);
  return (res.items || []).reduce((obj, cur) => {
    obj[cur.name] = cur.description;
    return obj;
  }, {});
};

module.exports = {
  listUrlMaps,
  listTargetProxies,
  listGlobalForwards,
  listBackendBuckets,
  listSslCertificates,
};
```

This code is a set of functions for interacting with Google Cloud's Compute Engine API. It uses the google-auth-library and googleapis libraries to authenticate and make requests to the API.

Functions

1. listUrlMaps(project, urlMap)

• Retrieves a list of URL Maps for a given project.
• Takes two parameters:
  • project: the ID of the project
  • urlMap: the name of the URL Map to filter by (optional)
• Returns a promise that resolves to an object with URL Map metadata (host rules, path matchers, fingerprint)

2. listTargetProxies(project, urlMap)

• Retrieves a list of Target Proxies for a given project.
• Takes two parameters:
  • project: the ID of the project
  • urlMap: the name of the URL Map associated with the Target Proxy (optional)
• Returns a promise that resolves to an object with Target Proxy metadata (SSL certificates)

3. listGlobalForwards(project, proxy, ip)

• Retrieves a list of Global Forwarding Rules for a given project.
• Takes three parameters:
  • project: the ID of the project
  • proxy: the name of the Target Proxy associated with the Forwarding Rule (optional)
  • ip: the IP address associated with the Forwarding Rule (optional)
• Returns a promise that resolves to an object with Forwarding Rule metadata

Common Pattern

All three functions follow a similar pattern:

1. They create a filter object to restrict the API request to a specific URL Map, Target Proxy, or Forwarding Rule.
2. They use the authorizeGoogle function to authenticate and get a client object.
3. They make a request to the Compute Engine API using the client object.
4. They process the response data and return a promise that resolves to an object with the desired metadata.

Note

This code uses the google-auth-library and googleapis libraries, which are not included in this snippet. You would need to have these libraries installed and imported in your project for this code to work.