Merge branch 'worktree-agent-afa3d6579009e448f'
This commit is contained in:
@@ -1,13 +1,433 @@
|
||||
#include "../GoogleDemos.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
|
||||
#include "../../fw/Router.hpp"
|
||||
#include "../../fw/Templates.hpp"
|
||||
#include "google/credentials.h"
|
||||
#include "google/ops/api_state.h"
|
||||
#include "google/ops/call_plan.h"
|
||||
#include "google/ops/calls.h"
|
||||
#include "google/ops/caps.h"
|
||||
#include "google/ops/ops.h"
|
||||
#include "google/resource.h"
|
||||
|
||||
namespace molo::example::app {
|
||||
|
||||
// Compute, Cloud Run, Functions, GKE, IAM, Resource Manager, Service Usage, Logging, Monitoring, Build, Artifact Registry. Stub: the package agent fills this in.
|
||||
// Google Cloud operations (Compute, Cloud Run, Functions, GKE, Build, Artifact
|
||||
// Registry, IAM, Resource Manager, Service Usage, Logging, Monitoring,
|
||||
// Scheduler, Tasks, Workflows, Eventarc, Billing, Asset, Org Policy) over the
|
||||
// real src/google/ops package. GET routes need no credential. Every route that
|
||||
// calls Google is a POST: 422 on bad input (checked first, against the
|
||||
// Discovery-derived call table), 503 google_not_configured without a
|
||||
// credential. Writes and destructive calls are dry runs unless the body says
|
||||
// "confirm":true; enabling or disabling an API is never done by the page on its
|
||||
// own and stays a dry run until a human confirms.
|
||||
|
||||
namespace {
|
||||
|
||||
namespace ops = google::ops;
|
||||
using Json = clients::body::Json;
|
||||
|
||||
constexpr std::size_t kMaxBody = 256 * 1024;
|
||||
constexpr std::size_t kMaxCallsShown = 500;
|
||||
constexpr int kDemoPages = 5;
|
||||
|
||||
const char kPage[] = R"GOOGLEOPS({% extends "base.html" %}
|
||||
{% block content %}
|
||||
<h1>Google Cloud operations</h1>
|
||||
<p class="hint">Compute, Cloud Run, Functions, GKE, Build, Artifact Registry, IAM,
|
||||
Resource Manager, Service Usage, Logging, Monitoring, Scheduler, Tasks, Workflows,
|
||||
Eventarc, Billing, Asset, Org Policy. Reads run; every change is a dry run until
|
||||
you tick confirm. Enabling an API is a human decision: the page only shows the plan.</p>
|
||||
<p id="go-config" class="hint">Checking Google credentials...</p>
|
||||
<section class="go">
|
||||
<h2>API state</h2>
|
||||
<label>Project <input id="go-project" type="text" maxlength="128" placeholder="project id"></label>
|
||||
<div class="go-actions">
|
||||
<button id="go-enabled" type="button" class="primary">Enabled APIs</button>
|
||||
<button id="go-iam" type="button">Is IAM enabled?</button>
|
||||
</div>
|
||||
<h2>Any call</h2>
|
||||
<label>Product
|
||||
<select id="go-product"></select></label>
|
||||
<label>Call
|
||||
<select id="go-rpc"></select></label>
|
||||
<p id="go-info" class="hint"></p>
|
||||
<label>Path parameters (JSON object) <textarea id="go-path" rows="2">{}</textarea></label>
|
||||
<label>Query (JSON object) <textarea id="go-query" rows="2">{}</textarea></label>
|
||||
<label>Body (JSON object) <textarea id="go-body" rows="3">{}</textarea></label>
|
||||
<label class="go-check"><input id="go-confirm" type="checkbox"> confirm (writes and deletes run only when ticked)</label>
|
||||
<div class="go-actions"><button id="go-send" type="button">Send</button></div>
|
||||
<p id="go-error" class="error" role="alert"></p>
|
||||
<pre id="go-out" class="go-out"></pre>
|
||||
</section>
|
||||
<style>
|
||||
.go label{display:block;margin:.5rem 0}
|
||||
.go input[type=text],.go textarea,.go select{width:100%;box-sizing:border-box}
|
||||
.go-check{display:flex;gap:.5rem;align-items:center}
|
||||
.go-actions{display:flex;flex-wrap:wrap;gap:.5rem;margin:.5rem 0}
|
||||
.go-out{overflow:auto;max-height:24rem;white-space:pre-wrap;word-break:break-word}
|
||||
</style>
|
||||
<script src="/embedded/google_ops.js"></script>
|
||||
{% endblock %}
|
||||
)GOOGLEOPS";
|
||||
|
||||
fw::Response json_out(const Json& j, int status = 200) {
|
||||
fw::Response res = fw::JsonResponse(j.dump(), status);
|
||||
res.headers.set("Cache-Control", "no-store");
|
||||
return res;
|
||||
}
|
||||
|
||||
[[noreturn]] void bad(const std::string& why) {
|
||||
throw fw::HttpError(422, "validation_error", why);
|
||||
}
|
||||
|
||||
std::string project_hint() { return google::Credentials::env("GOOGLE_CLOUD_PROJECT"); }
|
||||
|
||||
[[noreturn]] void rethrow(const google::GoogleError& e) {
|
||||
if (e.http_status() == 503 && e.status() == "NOT_CONFIGURED")
|
||||
throw fw::HttpError(503, "google_not_configured", e.message());
|
||||
if (e.service().empty() && e.status() == "INVALID_ARGUMENT")
|
||||
throw fw::HttpError(422, "validation_error", e.message());
|
||||
if (auto off = ops::ApiState::disabled(e, project_hint()))
|
||||
throw fw::HttpError(502, "api_not_enabled", off->loud());
|
||||
throw fw::HttpError(502, "google_error", e.status() + ": " + e.message());
|
||||
}
|
||||
|
||||
template <typename F>
|
||||
auto guarded(F&& f) -> decltype(f()) {
|
||||
try {
|
||||
return f();
|
||||
} catch (const google::GoogleError& e) {
|
||||
rethrow(e);
|
||||
}
|
||||
}
|
||||
|
||||
Json parse_body(const fw::Request& req) {
|
||||
if (req.body.size() > kMaxBody) throw fw::HttpError(413, "payload_too_large", "body too large");
|
||||
if (req.body.empty()) return Json::object();
|
||||
try {
|
||||
Json j = Json::parse(req.body);
|
||||
if (!j.is_object()) bad("body must be a JSON object");
|
||||
return j;
|
||||
} catch (const clients::body::JsonError&) {
|
||||
bad("body is not valid JSON");
|
||||
}
|
||||
}
|
||||
|
||||
std::string text(const Json& body, const char* key, bool required = false) {
|
||||
const Json* v = body.find(key);
|
||||
if (!v || v->is_null()) {
|
||||
if (required) bad(std::string(key) + " is required");
|
||||
return "";
|
||||
}
|
||||
if (!v->is_string()) bad(std::string(key) + " must be a string");
|
||||
return v->as_string();
|
||||
}
|
||||
|
||||
bool flag(const Json& body, const char* key) {
|
||||
const Json* v = body.find(key);
|
||||
if (!v || v->is_null()) return false;
|
||||
if (!v->is_bool()) bad(std::string(key) + " must be true or false");
|
||||
return v->as_bool();
|
||||
}
|
||||
|
||||
std::string project_of(const Json& body) {
|
||||
std::string p = text(body, "project");
|
||||
if (p.empty()) p = project_hint();
|
||||
if (p.empty()) bad("project is required (body.project or GOOGLE_CLOUD_PROJECT)");
|
||||
if (!ops::valid_name_segment(p)) bad("project is not a valid project id");
|
||||
return p;
|
||||
}
|
||||
|
||||
// Local checks failing as 422 (library "invalid" = bad input).
|
||||
template <typename F>
|
||||
auto local(F&& f) -> decltype(f()) {
|
||||
return guarded(std::forward<F>(f));
|
||||
}
|
||||
|
||||
class OpsRoutes {
|
||||
public:
|
||||
explicit OpsRoutes(std::shared_ptr<google::GoogleClient> client) : client_(std::move(client)) {}
|
||||
|
||||
fw::Response status(const fw::Request&) const {
|
||||
Json o = Json::object();
|
||||
o.set("configured", Json(client_->configured()));
|
||||
o.set("project_set", Json(!project_hint().empty()));
|
||||
o.set("products", Json(static_cast<int>(ops::product_count())));
|
||||
o.set("calls", Json(static_cast<int>(ops::call_count())));
|
||||
o.set("max_pages", Json(kDemoPages));
|
||||
return json_out(o);
|
||||
}
|
||||
|
||||
// The discovery-derived table, optionally one product: ?product=run
|
||||
fw::Response calls(const fw::Request& req) const {
|
||||
std::string only = req.query_or("product", "");
|
||||
Json arr = Json::array();
|
||||
Json prods = Json::array();
|
||||
for (std::size_t i = 0; i < ops::product_count(); ++i) {
|
||||
Json p = Json::object();
|
||||
p.set("name", Json(ops::products()[i].name));
|
||||
p.set("version", Json(ops::products()[i].version));
|
||||
p.set("revision", Json(ops::products()[i].revision));
|
||||
prods.push(p);
|
||||
}
|
||||
std::size_t shown = 0;
|
||||
for (std::size_t i = 0; i < ops::call_count() && shown < kMaxCallsShown; ++i) {
|
||||
const ops::CallSpec& c = ops::call_table()[i];
|
||||
if (!only.empty() && c.product() != only) continue;
|
||||
Json row = Json::object();
|
||||
row.set("rpc", Json(c.rpc));
|
||||
row.set("http", Json(c.http));
|
||||
row.set("path", Json(c.path));
|
||||
row.set("safety", Json(c.safe() == ops::Safety::kRead
|
||||
? "read"
|
||||
: c.safe() == ops::Safety::kWrite ? "write" : "destructive"));
|
||||
row.set("list", Json(c.is_list()));
|
||||
row.set("body_fields", Json(c.body_fields));
|
||||
row.set("query", Json(c.query_params));
|
||||
arr.push(row);
|
||||
++shown;
|
||||
}
|
||||
Json o = Json::object();
|
||||
o.set("products", prods);
|
||||
o.set("calls", arr);
|
||||
return json_out(o);
|
||||
}
|
||||
|
||||
// Any table row. Body: {"rpc","path":{},"query":{},"body":{},"confirm":bool}.
|
||||
fw::Response call(const fw::Request& req) const {
|
||||
Json b = parse_body(req);
|
||||
std::string rpc = text(b, "rpc", true);
|
||||
bool confirm = flag(b, "confirm");
|
||||
ops::Args args = local([&] { return ops::Args::from_json(b); });
|
||||
const ops::CallSpec* spec = ops::find_call(rpc);
|
||||
if (!spec) bad("unknown call: " + rpc);
|
||||
ops::CallPlan plan = local([&] { return ops::CallPlan::build(*spec, args); });
|
||||
if (spec->safe() != ops::Safety::kRead) {
|
||||
ops::Outcome out;
|
||||
out.plan = plan;
|
||||
if (!confirm) return json_out(out.to_json()); // dry run: no credential needed
|
||||
need_credential(spec->product());
|
||||
return guarded([&] {
|
||||
return json_out(ops::OpsClient(client_).execute(rpc, args, true).to_json());
|
||||
});
|
||||
}
|
||||
need_credential(spec->product());
|
||||
return guarded([&] {
|
||||
ops::OpsClient c(client_);
|
||||
Json o = Json::object();
|
||||
o.set("rpc", Json(rpc));
|
||||
if (spec->is_list()) o.set("items", c.list(rpc, args, kDemoPages));
|
||||
else o.set("response", c.read(rpc, args));
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
|
||||
// Service Usage: list, get, batch_get, enable, disable. enable and disable
|
||||
// are dry runs unless confirm is true.
|
||||
fw::Response services(const fw::Request& req) const {
|
||||
Json b = parse_body(req);
|
||||
std::string action = text(b, "action", true);
|
||||
std::string project = project_of(b);
|
||||
std::string parent = local([&] { return ops::Names::project(project); });
|
||||
if (action == "list") {
|
||||
std::string state = text(b, "state");
|
||||
if (!state.empty() && state != "ENABLED" && state != "DISABLED")
|
||||
bad("state must be ENABLED or DISABLED");
|
||||
std::string filter = state.empty() ? "" : "state:" + state;
|
||||
need_credential("serviceusage");
|
||||
return guarded([&] {
|
||||
ops::ServiceUsage su(client_);
|
||||
Json items = su.list_services(parent, filter);
|
||||
Json arr = Json::array();
|
||||
for (const Json& item : items.as_array()) {
|
||||
ops::ServiceState s = ops::ServiceState::from_json(item);
|
||||
Json row = Json::object();
|
||||
row.set("api", Json(s.api));
|
||||
row.set("state", Json(s.state));
|
||||
row.set("title", Json(s.title));
|
||||
arr.push(row);
|
||||
}
|
||||
Json o = Json::object();
|
||||
o.set("services", arr);
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
if (action == "get" || action == "enable" || action == "disable") {
|
||||
std::string name = local([&] {
|
||||
return ops::ServiceUsage::service_name(project, text(b, "api", true));
|
||||
});
|
||||
if (action == "get") {
|
||||
need_credential("serviceusage");
|
||||
return guarded([&] { return json_out(ops::ServiceUsage(client_).service(name)); });
|
||||
}
|
||||
bool confirm = flag(b, "confirm");
|
||||
ops::ServiceUsage su(client_);
|
||||
ops::Outcome out = local([&] {
|
||||
return action == "enable" ? su.enable(name, false) : su.disable(name, false, false);
|
||||
});
|
||||
if (!confirm) return json_out(out.to_json());
|
||||
need_credential("serviceusage");
|
||||
return guarded([&] {
|
||||
return json_out((action == "enable" ? su.enable(name, true) : su.disable(name, false, true))
|
||||
.to_json());
|
||||
});
|
||||
}
|
||||
if (action == "batch_get") {
|
||||
const Json* apis = b.find("apis");
|
||||
if (!apis || !apis->is_array()) bad("apis must be an array of API names");
|
||||
std::vector<std::string> names;
|
||||
for (const Json& a : apis->as_array()) {
|
||||
if (!a.is_string()) bad("apis must be strings");
|
||||
names.push_back(local([&] { return ops::ServiceUsage::service_name(project, a.as_string()); }));
|
||||
}
|
||||
if (names.empty() || names.size() > ops::OpsCaps::kMaxBatchNames) bad("apis must hold 1..20 names");
|
||||
need_credential("serviceusage");
|
||||
return guarded([&] { return json_out(ops::ServiceUsage(client_).batch_get(parent, names)); });
|
||||
}
|
||||
bad("action must be list, get, batch_get, enable or disable");
|
||||
}
|
||||
|
||||
// Resource Manager: get, search.
|
||||
fw::Response projects(const fw::Request& req) const {
|
||||
Json b = parse_body(req);
|
||||
std::string action = text(b, "action", true);
|
||||
if (action == "get") {
|
||||
std::string name = local([&] { return ops::Names::project(project_of(b)); });
|
||||
need_credential("cloudresourcemanager");
|
||||
return guarded([&] { return json_out(ops::ResourceManager(client_).project(name)); });
|
||||
}
|
||||
if (action == "search") {
|
||||
std::string query = text(b, "query");
|
||||
if (query.size() > 256) bad("query too long");
|
||||
need_credential("cloudresourcemanager");
|
||||
return guarded([&] {
|
||||
Json o = Json::object();
|
||||
o.set("projects", ops::ResourceManager(client_).search_projects(query));
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
bad("action must be get or search");
|
||||
}
|
||||
|
||||
// IAM: service accounts, roles, permission test; signing via IAM Credentials.
|
||||
fw::Response iam(const fw::Request& req) const {
|
||||
Json b = parse_body(req);
|
||||
std::string action = text(b, "action", true);
|
||||
std::string project = project_of(b);
|
||||
std::string parent = local([&] { return ops::Names::project(project); });
|
||||
if (action == "service_accounts") {
|
||||
need_credential("iam");
|
||||
return guarded([&] {
|
||||
Json o = Json::object();
|
||||
o.set("accounts", ops::Iam(client_).service_accounts(parent));
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
if (action == "roles") {
|
||||
need_credential("iam");
|
||||
return guarded([&] {
|
||||
Json o = Json::object();
|
||||
o.set("roles", ops::Iam(client_).project_roles(parent));
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
if (action == "test_permissions" || action == "sign_jwt" || action == "sign_blob") {
|
||||
std::string account = text(b, "account", true);
|
||||
std::string name = local([&] {
|
||||
std::string n = "projects/" + project + "/serviceAccounts/" + account;
|
||||
ops::check_resource_name("account", n, "projects/*/serviceAccounts/*");
|
||||
return n;
|
||||
});
|
||||
if (action == "test_permissions") {
|
||||
const Json* perms = b.find("permissions");
|
||||
if (!perms || !perms->is_array() || perms->as_array().empty() || perms->as_array().size() > 100)
|
||||
bad("permissions must be an array of 1..100 strings");
|
||||
std::vector<std::string> list;
|
||||
for (const Json& p : perms->as_array()) {
|
||||
if (!p.is_string()) bad("permissions must be strings");
|
||||
list.push_back(p.as_string());
|
||||
}
|
||||
need_credential("iam");
|
||||
return guarded([&] { return json_out(ops::Iam(client_).test_permissions(name, list)); });
|
||||
}
|
||||
std::string payload = text(b, "payload", true);
|
||||
if (payload.size() > ops::OpsCaps::kMaxSignPayloadBytes) bad("payload too large");
|
||||
need_credential("iamcredentials");
|
||||
return guarded([&] {
|
||||
ops::IamCredentials cr(client_);
|
||||
return json_out(action == "sign_jwt" ? cr.sign_jwt(name, payload) : cr.sign_blob(name, payload));
|
||||
});
|
||||
}
|
||||
bad("action must be service_accounts, roles, test_permissions, sign_jwt or sign_blob");
|
||||
}
|
||||
|
||||
// Logging: recent entries of a project.
|
||||
fw::Response logs(const fw::Request& req) const {
|
||||
Json b = parse_body(req);
|
||||
std::string parent = local([&] { return ops::Names::project(project_of(b)); });
|
||||
std::string filter = text(b, "filter");
|
||||
int limit = 20;
|
||||
if (const Json* l = b.find("limit"); l && !l->is_null()) {
|
||||
if (!l->is_number()) bad("limit must be a number");
|
||||
limit = static_cast<int>(l->as_int());
|
||||
}
|
||||
if (limit < 1 || limit > 100) bad("limit must be 1..100");
|
||||
if (filter.size() > 2048) bad("filter too long");
|
||||
need_credential("logging");
|
||||
return guarded([&] {
|
||||
Json o = Json::object();
|
||||
o.set("entries", ops::CloudLogging(client_).entries({parent}, filter, "timestamp desc", limit));
|
||||
return json_out(o);
|
||||
});
|
||||
}
|
||||
|
||||
private:
|
||||
void need_credential(const std::string& product) const {
|
||||
if (!client_->configured()) {
|
||||
google::NotConfiguredError e(product);
|
||||
rethrow(e);
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<google::GoogleClient> client_;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
void register_google_ops_demo(fw::Router& router, Services& services) {
|
||||
(void)router;
|
||||
(void)services;
|
||||
if (!services.google) services.google = google::GoogleClient::from_env();
|
||||
auto client = services.google;
|
||||
fw::Environment* env = services.templates.get();
|
||||
services.templates->add_template("google_ops.html", kPage);
|
||||
services.add_feature("google-ops", "/google/ops");
|
||||
|
||||
auto routes = std::make_shared<OpsRoutes>(client);
|
||||
|
||||
router.get("/google/ops", "google-ops-page", [env](fw::Request req) {
|
||||
(void)req;
|
||||
fw::TemplateCtx ctx;
|
||||
ctx["title"] = std::string("Google Cloud operations");
|
||||
return fw::Response(200, env->render("google_ops.html", ctx), "text/html; charset=utf-8");
|
||||
});
|
||||
|
||||
using Handler = fw::Response (OpsRoutes::*)(const fw::Request&) const;
|
||||
auto get = [&](const char* path, const char* name, Handler h) {
|
||||
router.get(path, name, [routes, h](fw::Request req) { return ((*routes).*h)(req); });
|
||||
};
|
||||
auto post = [&](const char* path, const char* name, Handler h) {
|
||||
router.post(path, name, [routes, h](fw::Request req) { return ((*routes).*h)(req); });
|
||||
};
|
||||
get("/google/ops/status", "google-ops-status", &OpsRoutes::status);
|
||||
get("/google/ops/calls", "google-ops-calls", &OpsRoutes::calls);
|
||||
post("/google/ops/call", "google-ops-call", &OpsRoutes::call);
|
||||
post("/google/ops/services", "google-ops-services", &OpsRoutes::services);
|
||||
post("/google/ops/projects", "google-ops-projects", &OpsRoutes::projects);
|
||||
post("/google/ops/iam", "google-ops-iam", &OpsRoutes::iam);
|
||||
post("/google/ops/logs", "google-ops-logs", &OpsRoutes::logs);
|
||||
}
|
||||
|
||||
} // namespace molo::example::app
|
||||
|
||||
@@ -0,0 +1,81 @@
|
||||
// Google Cloud operations page: thin client over /google/ops/* (all limits server side).
|
||||
(function () {
|
||||
"use strict";
|
||||
var $ = function (id) { return document.getElementById(id); };
|
||||
var out = $("go-out"), err = $("go-error");
|
||||
var calls = [];
|
||||
|
||||
function show(res) {
|
||||
return res.text().then(function (t) {
|
||||
var j;
|
||||
try { j = JSON.parse(t); } catch (e) { j = { message: t }; }
|
||||
if (!res.ok) { err.textContent = j.message || ("HTTP " + res.status); out.textContent = ""; }
|
||||
else { out.textContent = JSON.stringify(j, null, 2); }
|
||||
});
|
||||
}
|
||||
function post(path, body) {
|
||||
err.textContent = "";
|
||||
out.textContent = "...";
|
||||
return fetch(path, {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify(body)
|
||||
}).then(show).catch(function (e) { err.textContent = String(e); out.textContent = ""; });
|
||||
}
|
||||
function json(id) {
|
||||
try { return JSON.parse($(id).value || "{}"); }
|
||||
catch (e) { err.textContent = "Field " + id + " is not valid JSON"; return null; }
|
||||
}
|
||||
function project() { return $("go-project").value.trim(); }
|
||||
|
||||
fetch("/google/ops/status").then(function (r) { return r.json(); }).then(function (s) {
|
||||
$("go-config").textContent = s.configured
|
||||
? "Google credential found. " + s.calls + " calls in " + s.products + " products."
|
||||
: "No Google credential: calls answer 503 until one is configured.";
|
||||
});
|
||||
|
||||
function fillRpcs() {
|
||||
var p = $("go-product").value, sel = $("go-rpc");
|
||||
sel.innerHTML = "";
|
||||
calls.filter(function (c) { return c.rpc.split(".")[0] === p; }).forEach(function (c) {
|
||||
var o = document.createElement("option");
|
||||
o.value = c.rpc;
|
||||
o.textContent = c.rpc.substring(p.length + 1) + " [" + c.safety + "]";
|
||||
sel.appendChild(o);
|
||||
});
|
||||
describe();
|
||||
}
|
||||
function describe() {
|
||||
var c = calls.filter(function (x) { return x.rpc === $("go-rpc").value; })[0];
|
||||
$("go-info").textContent = c ? c.http + " " + c.path + (c.query ? " query: " + c.query : "") +
|
||||
(c.body_fields ? " body: " + c.body_fields : "") : "";
|
||||
}
|
||||
fetch("/google/ops/calls").then(function (r) { return r.json(); }).then(function (d) {
|
||||
calls = d.calls;
|
||||
var sel = $("go-product");
|
||||
d.products.forEach(function (p) {
|
||||
var o = document.createElement("option");
|
||||
o.value = p.name;
|
||||
o.textContent = p.name + " " + p.version;
|
||||
sel.appendChild(o);
|
||||
});
|
||||
fillRpcs();
|
||||
});
|
||||
$("go-product").onchange = fillRpcs;
|
||||
$("go-rpc").onchange = describe;
|
||||
|
||||
$("go-enabled").onclick = function () {
|
||||
post("/google/ops/services", { action: "list", state: "ENABLED", project: project() });
|
||||
};
|
||||
$("go-iam").onclick = function () {
|
||||
post("/google/ops/services", { action: "get", api: "iam.googleapis.com", project: project() });
|
||||
};
|
||||
$("go-send").onclick = function () {
|
||||
var path = json("go-path"), query = json("go-query"), body = json("go-body");
|
||||
if (path === null || query === null || body === null) return;
|
||||
post("/google/ops/call", {
|
||||
rpc: $("go-rpc").value, path: path, query: query, body: body,
|
||||
confirm: $("go-confirm").checked
|
||||
});
|
||||
};
|
||||
})();
|
||||
Reference in New Issue
Block a user