grpc-flamingo 1.11.0 → 1.15.0

data/src/core/lib/gpr/fork.cc

@@ -1,78 +0,0 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gpr/fork.h"
-
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/useful.h"
-
-/*
- * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
- *       AROUND VERY SPECIFIC USE CASES.
- */
-
-static int override_fork_support_enabled = -1;
-static int fork_support_enabled;
-
-void grpc_fork_support_init() {
-#ifdef GRPC_ENABLE_FORK_SUPPORT
-  fork_support_enabled = 1;
-#else
-  fork_support_enabled = 0;
-#endif
-  bool env_var_set = false;
-  char* env = gpr_getenv("GRPC_ENABLE_FORK_SUPPORT");
-  if (env != nullptr) {
-    static const char* truthy[] = {"yes",  "Yes",  "YES", "true",
-                                   "True", "TRUE", "1"};
-    static const char* falsey[] = {"no",    "No",    "NO", "false",
-                                   "False", "FALSE", "0"};
-    for (size_t i = 0; i < GPR_ARRAY_SIZE(truthy); i++) {
-      if (0 == strcmp(env, truthy[i])) {
-        fork_support_enabled = 1;
-        env_var_set = true;
-        break;
-      }
-    }
-    if (!env_var_set) {
-      for (size_t i = 0; i < GPR_ARRAY_SIZE(falsey); i++) {
-        if (0 == strcmp(env, falsey[i])) {
-          fork_support_enabled = 0;
-          env_var_set = true;
-          break;
-        }
-      }
-    }
-    gpr_free(env);
-  }
-  if (override_fork_support_enabled != -1) {
-    fork_support_enabled = override_fork_support_enabled;
-  }
-}
-
-int grpc_fork_support_enabled() { return fork_support_enabled; }
-
-void grpc_enable_fork_support(int enable) {
-  override_fork_support_enabled = enable;
-}

data/src/core/tsi/transport_security_adapter.cc

@@ -1,235 +0,0 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/tsi/transport_security_adapter.h"
-
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include "src/core/tsi/transport_security.h"
-
-#define TSI_ADAPTER_INITIAL_BUFFER_SIZE 256
-
-/* --- tsi_adapter_handshaker_result implementation ---*/
-
-typedef struct {
-  tsi_handshaker_result base;
-  tsi_handshaker* wrapped;
-  unsigned char* unused_bytes;
-  size_t unused_bytes_size;
-} tsi_adapter_handshaker_result;
-
-static tsi_result adapter_result_extract_peer(const tsi_handshaker_result* self,
-                                              tsi_peer* peer) {
-  tsi_adapter_handshaker_result* impl = (tsi_adapter_handshaker_result*)self;
-  return tsi_handshaker_extract_peer(impl->wrapped, peer);
-}
-
-static tsi_result adapter_result_create_frame_protector(
-    const tsi_handshaker_result* self, size_t* max_output_protected_frame_size,
-    tsi_frame_protector** protector) {
-  tsi_adapter_handshaker_result* impl = (tsi_adapter_handshaker_result*)self;
-  return tsi_handshaker_create_frame_protector(
-      impl->wrapped, max_output_protected_frame_size, protector);
-}
-
-static tsi_result adapter_result_get_unused_bytes(
-    const tsi_handshaker_result* self, const unsigned char** bytes,
-    size_t* byte_size) {
-  tsi_adapter_handshaker_result* impl = (tsi_adapter_handshaker_result*)self;
-  *bytes = impl->unused_bytes;
-  *byte_size = impl->unused_bytes_size;
-  return TSI_OK;
-}
-
-static void adapter_result_destroy(tsi_handshaker_result* self) {
-  tsi_adapter_handshaker_result* impl =
-      reinterpret_cast<tsi_adapter_handshaker_result*>(self);
-  tsi_handshaker_destroy(impl->wrapped);
-  gpr_free(impl->unused_bytes);
-  gpr_free(self);
-}
-
-static const tsi_handshaker_result_vtable result_vtable = {
-    adapter_result_extract_peer,
-    nullptr, /* create_zero_copy_grpc_protector */
-    adapter_result_create_frame_protector,
-    adapter_result_get_unused_bytes,
-    adapter_result_destroy,
-};
-
-/* Ownership of wrapped tsi_handshaker is transferred to the result object.  */
-static tsi_result tsi_adapter_create_handshaker_result(
-    tsi_handshaker* wrapped, const unsigned char* unused_bytes,
-    size_t unused_bytes_size, tsi_handshaker_result** handshaker_result) {
-  if (wrapped == nullptr ||
-      (unused_bytes_size > 0 && unused_bytes == nullptr)) {
-    return TSI_INVALID_ARGUMENT;
-  }
-  tsi_adapter_handshaker_result* impl =
-      static_cast<tsi_adapter_handshaker_result*>(gpr_zalloc(sizeof(*impl)));
-  impl->base.vtable = &result_vtable;
-  impl->wrapped = wrapped;
-  impl->unused_bytes_size = unused_bytes_size;
-  if (unused_bytes_size > 0) {
-    impl->unused_bytes =
-        static_cast<unsigned char*>(gpr_malloc(unused_bytes_size));
-    memcpy(impl->unused_bytes, unused_bytes, unused_bytes_size);
-  } else {
-    impl->unused_bytes = nullptr;
-  }
-  *handshaker_result = &impl->base;
-  return TSI_OK;
-}
-
-/* --- tsi_adapter_handshaker implementation ---*/
-
-typedef struct {
-  tsi_handshaker base;
-  tsi_handshaker* wrapped;
-  unsigned char* adapter_buffer;
-  size_t adapter_buffer_size;
-} tsi_adapter_handshaker;
-
-static tsi_result adapter_get_bytes_to_send_to_peer(tsi_handshaker* self,
-                                                    unsigned char* bytes,
-                                                    size_t* bytes_size) {
-  return tsi_handshaker_get_bytes_to_send_to_peer(
-      tsi_adapter_handshaker_get_wrapped(self), bytes, bytes_size);
-}
-
-static tsi_result adapter_process_bytes_from_peer(tsi_handshaker* self,
-                                                  const unsigned char* bytes,
-                                                  size_t* bytes_size) {
-  return tsi_handshaker_process_bytes_from_peer(
-      tsi_adapter_handshaker_get_wrapped(self), bytes, bytes_size);
-}
-
-static tsi_result adapter_get_result(tsi_handshaker* self) {
-  return tsi_handshaker_get_result(tsi_adapter_handshaker_get_wrapped(self));
-}
-
-static tsi_result adapter_extract_peer(tsi_handshaker* self, tsi_peer* peer) {
-  return tsi_handshaker_extract_peer(tsi_adapter_handshaker_get_wrapped(self),
-                                     peer);
-}
-
-static tsi_result adapter_create_frame_protector(
-    tsi_handshaker* self, size_t* max_protected_frame_size,
-    tsi_frame_protector** protector) {
-  return tsi_handshaker_create_frame_protector(
-      tsi_adapter_handshaker_get_wrapped(self), max_protected_frame_size,
-      protector);
-}
-
-static void adapter_destroy(tsi_handshaker* self) {
-  tsi_adapter_handshaker* impl =
-      reinterpret_cast<tsi_adapter_handshaker*>(self);
-  tsi_handshaker_destroy(impl->wrapped);
-  gpr_free(impl->adapter_buffer);
-  gpr_free(self);
-}
-
-static tsi_result adapter_next(
-    tsi_handshaker* self, const unsigned char* received_bytes,
-    size_t received_bytes_size, const unsigned char** bytes_to_send,
-    size_t* bytes_to_send_size, tsi_handshaker_result** handshaker_result,
-    tsi_handshaker_on_next_done_cb cb, void* user_data) {
-  /* Input sanity check.  */
-  if ((received_bytes_size > 0 && received_bytes == nullptr) ||
-      bytes_to_send == nullptr || bytes_to_send_size == nullptr ||
-      handshaker_result == nullptr) {
-    return TSI_INVALID_ARGUMENT;
-  }
-
-  /* If there are received bytes, process them first.  */
-  tsi_adapter_handshaker* impl =
-      reinterpret_cast<tsi_adapter_handshaker*>(self);
-  tsi_result status = TSI_OK;
-  size_t bytes_consumed = received_bytes_size;
-  if (received_bytes_size > 0) {
-    status = tsi_handshaker_process_bytes_from_peer(
-        impl->wrapped, received_bytes, &bytes_consumed);
-    if (status != TSI_OK) return status;
-  }
-
-  /* Get bytes to send to the peer, if available.  */
-  size_t offset = 0;
-  do {
-    size_t to_send_size = impl->adapter_buffer_size - offset;
-    status = tsi_handshaker_get_bytes_to_send_to_peer(
-        impl->wrapped, impl->adapter_buffer + offset, &to_send_size);
-    offset += to_send_size;
-    if (status == TSI_INCOMPLETE_DATA) {
-      impl->adapter_buffer_size *= 2;
-      impl->adapter_buffer = static_cast<unsigned char*>(
-          gpr_realloc(impl->adapter_buffer, impl->adapter_buffer_size));
-    }
-  } while (status == TSI_INCOMPLETE_DATA);
-  if (status != TSI_OK) return status;
-  *bytes_to_send = impl->adapter_buffer;
-  *bytes_to_send_size = offset;
-
-  /* If handshake completes, create tsi_handshaker_result.  */
-  if (tsi_handshaker_is_in_progress(impl->wrapped)) {
-    *handshaker_result = nullptr;
-  } else {
-    size_t unused_bytes_size = received_bytes_size - bytes_consumed;
-    const unsigned char* unused_bytes =
-        unused_bytes_size == 0 ? nullptr : received_bytes + bytes_consumed;
-    status = tsi_adapter_create_handshaker_result(
-        impl->wrapped, unused_bytes, unused_bytes_size, handshaker_result);
-    if (status == TSI_OK) {
-      impl->base.handshaker_result_created = true;
-      impl->wrapped = nullptr;
-    }
-  }
-  return status;
-}
-
-static const tsi_handshaker_vtable handshaker_vtable = {
-    adapter_get_bytes_to_send_to_peer,
-    adapter_process_bytes_from_peer,
-    adapter_get_result,
-    adapter_extract_peer,
-    adapter_create_frame_protector,
-    adapter_destroy,
-    adapter_next,
-};
-
-tsi_handshaker* tsi_create_adapter_handshaker(tsi_handshaker* wrapped) {
-  GPR_ASSERT(wrapped != nullptr);
-  tsi_adapter_handshaker* impl =
-      static_cast<tsi_adapter_handshaker*>(gpr_zalloc(sizeof(*impl)));
-  impl->base.vtable = &handshaker_vtable;
-  impl->wrapped = wrapped;
-  impl->adapter_buffer_size = TSI_ADAPTER_INITIAL_BUFFER_SIZE;
-  impl->adapter_buffer =
-      static_cast<unsigned char*>(gpr_malloc(impl->adapter_buffer_size));
-  return &impl->base;
-}
-
-tsi_handshaker* tsi_adapter_handshaker_get_wrapped(tsi_handshaker* adapter) {
-  if (adapter == nullptr) return nullptr;
-  tsi_adapter_handshaker* impl =
-      reinterpret_cast<tsi_adapter_handshaker*>(adapter);
-  return impl->wrapped;
-}

data/src/core/tsi/transport_security_adapter.h

@@ -1,41 +0,0 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_TSI_TRANSPORT_SECURITY_ADAPTER_H
-#define GRPC_CORE_TSI_TRANSPORT_SECURITY_ADAPTER_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/tsi/transport_security_interface.h"
-
-/* Create a tsi handshaker that takes an implementation of old interface and
-   converts into an implementation of new interface. In the old interface,
-   there are get_bytes_to_send_to_peer, process_bytes_from_peer, get_result,
-   extract_peer, and create_frame_protector. In the new interface, only next
-   method is needed. See transport_security_interface.h for details. Note that
-   this tsi adapter handshaker is temporary. It will be removed once TSI has
-   been fully migrated to the new interface.
-   Ownership of input tsi_handshaker is transferred to this new adapter.  */
-tsi_handshaker* tsi_create_adapter_handshaker(tsi_handshaker* wrapped);
-
-/* Given a tsi adapter handshaker, return the original wrapped handshaker. The
-   adapter still owns the wrapped handshaker which should not be destroyed by
-   the caller. */
-tsi_handshaker* tsi_adapter_handshaker_get_wrapped(tsi_handshaker* adapter);
-
-#endif /* GRPC_CORE_TSI_TRANSPORT_SECURITY_ADAPTER_H */

data/src/ruby/bin/apis/google/protobuf/empty.rb

@@ -1,29 +0,0 @@
-# Copyright 2015 gRPC authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: google/protobuf/empty.proto
-
-require 'google/protobuf'
-
-Google::Protobuf::DescriptorPool.generated_pool.build do
-  add_message "google.protobuf.Empty" do
-  end
-end
-
-module Google
-  module Protobuf
-    Empty = Google::Protobuf::DescriptorPool.generated_pool.lookup("google.protobuf.Empty").msgclass
-  end
-end

data/src/ruby/bin/apis/pubsub_demo.rb

@@ -1,241 +0,0 @@
-#!/usr/bin/env ruby
-
-# Copyright 2015 gRPC authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# pubsub_demo demos accesses the Google PubSub API via its gRPC interface
-#
-# $ GOOGLE_APPLICATION_CREDENTIALS=<path_to_service_account_key_file> \
-#   path/to/pubsub_demo.rb \
-#   [--action=<chosen_demo_action> ]
-#
-# There are options related to the chosen action, see #parse_args below.
-# - the possible actions are given by the method names of NamedAction class
-# - the default action is list_some_topics
-
-this_dir = File.expand_path(File.dirname(__FILE__))
-lib_dir = File.join(File.dirname(File.dirname(this_dir)), 'lib')
-$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
-$LOAD_PATH.unshift(this_dir) unless $LOAD_PATH.include?(this_dir)
-
-require 'optparse'
-
-require 'grpc'
-require 'googleauth'
-require 'google/protobuf'
-
-require 'google/protobuf/empty'
-require 'tech/pubsub/proto/pubsub'
-require 'tech/pubsub/proto/pubsub_services'
-
-# creates a SSL Credentials from the production certificates.
-def ssl_creds
-  GRPC::Core::ChannelCredentials.new()
-end
-
-# Builds the metadata authentication update proc.
-def auth_proc(opts)
-  auth_creds = Google::Auth.get_application_default
-  return auth_creds.updater_proc
-end
-
-# Creates a stub for accessing the publisher service.
-def publisher_stub(opts)
-  address = "#{opts.host}:#{opts.port}"
-  stub_clz = Tech::Pubsub::PublisherService::Stub # shorter
-  GRPC.logger.info("... access PublisherService at #{address}")
-  call_creds = GRPC::Core::CallCredentials.new(auth_proc(opts))
-  combined_creds = ssl_creds.compose(call_creds)
-  stub_clz.new(address, creds: combined_creds,
-               GRPC::Core::Channel::SSL_TARGET => opts.host)
-end
-
-# Creates a stub for accessing the subscriber service.
-def subscriber_stub(opts)
-  address = "#{opts.host}:#{opts.port}"
-  stub_clz = Tech::Pubsub::SubscriberService::Stub # shorter
-  GRPC.logger.info("... access SubscriberService at #{address}")
-  call_creds = GRPC::Core::CallCredentials.new(auth_proc(opts))
-  combined_creds = ssl_creds.compose(call_creds)
-  stub_clz.new(address, creds: combined_creds,
-               GRPC::Core::Channel::SSL_TARGET => opts.host)
-end
-
-# defines methods corresponding to each interop test case.
-class NamedActions
-  include Tech::Pubsub
-
-  # Initializes NamedActions
-  #
-  # @param pub [Stub] a stub for accessing the publisher service
-  # @param sub [Stub] a stub for accessing the publisher service
-  # @param args [Args] provides access to the command line
-  def initialize(pub, sub, args)
-    @pub = pub
-    @sub = sub
-    @args = args
-  end
-
-  # Removes the test topic if it exists
-  def remove_topic
-    name = test_topic_name
-    p "... removing Topic #{name}"
-    @pub.delete_topic(DeleteTopicRequest.new(topic: name))
-    p "removed Topic: #{name} OK"
-  rescue GRPC::BadStatus => e
-    p "Could not delete a topics: rpc failed with '#{e}'"
-  end
-
-  # Creates a test topic
-  def create_topic
-    name = test_topic_name
-    p "... creating Topic #{name}"
-    resp = @pub.create_topic(Topic.new(name: name))
-    p "created Topic: #{resp.name} OK"
-  rescue GRPC::BadStatus => e
-    p "Could not create a topics: rpc failed with '#{e}'"
-  end
-
-  # Lists topics in the project
-  def list_some_topics
-    p 'Listing topics'
-    p '-------------_'
-    list_project_topics.topic.each { |t| p t.name }
-  rescue GRPC::BadStatus => e
-    p "Could not list topics: rpc failed with '#{e}'"
-  end
-
-  # Checks if a topics exists in a project
-  def check_exists
-    name = test_topic_name
-    p "... checking for topic #{name}"
-    exists = topic_exists?(name)
-    p "#{name} is a topic" if exists
-    p "#{name} is not a topic" unless exists
-  rescue GRPC::BadStatus => e
-    p "Could not check for a topics: rpc failed with '#{e}'"
-  end
-
-  # Publishes some messages
-  def random_pub_sub
-    topic_name, sub_name = test_topic_name, test_sub_name
-    create_topic_if_needed(topic_name)
-    @sub.create_subscription(Subscription.new(name: sub_name,
-                                              topic: topic_name))
-    msg_count = rand(10..30)
-    msg_count.times do |x|
-      msg = PubsubMessage.new(data: "message #{x}")
-      @pub.publish(PublishRequest.new(topic: topic_name, message: msg))
-    end
-    p "Sent #{msg_count} messages to #{topic_name}, checking for them now."
-    batch = @sub.pull_batch(PullBatchRequest.new(subscription: sub_name,
-                                                 max_events: msg_count))
-    ack_ids = batch.pull_responses.map { |x| x.ack_id }
-    p "Got #{ack_ids.size} messages; acknowledging them.."
-    @sub.acknowledge(AcknowledgeRequest.new(subscription: sub_name,
-                                            ack_id: ack_ids))
-    p "Test messages were acknowledged OK, deleting the subscription"
-    del_req = DeleteSubscriptionRequest.new(subscription: sub_name)
-    @sub.delete_subscription(del_req)
-  rescue GRPC::BadStatus => e
-    p "Could not do random pub sub: rpc failed with '#{e}'"
-  end
-
-  private
-
-  # test_topic_name is the topic name to use in this test.
-  def test_topic_name
-    unless @args.topic_name.nil?
-      return "/topics/#{@args.project_id}/#{@args.topic_name}"
-    end
-    now_text = Time.now.utc.strftime('%Y%m%d%H%M%S%L')
-    "/topics/#{@args.project_id}/#{ENV['USER']}-#{now_text}"
-  end
-
-  # test_sub_name is the subscription name to use in this test.
-  def test_sub_name
-    unless @args.sub_name.nil?
-      return "/subscriptions/#{@args.project_id}/#{@args.sub_name}"
-    end
-    now_text = Time.now.utc.strftime('%Y%m%d%H%M%S%L')
-    "/subscriptions/#{@args.project_id}/#{ENV['USER']}-#{now_text}"
-  end
-
-  # determines if the topic name exists
-  def topic_exists?(name)
-    topics = list_project_topics.topic.map { |t| t.name }
-    topics.include?(name)
-  end
-
-  def create_topic_if_needed(name)
-    return if topic_exists?(name)
-    @pub.create_topic(Topic.new(name: name))
-  end
-
-  def list_project_topics
-    q = "cloud.googleapis.com/project in (/projects/#{@args.project_id})"
-    @pub.list_topics(ListTopicsRequest.new(query: q))
-  end
-end
-
-# Args is used to hold the command line info.
-Args = Struct.new(:host, :port, :action, :project_id, :topic_name,
-                  :sub_name)
-
-# validates the command line options, returning them as an Arg.
-def parse_args
-  args = Args.new('pubsub-staging.googleapis.com',
-                   443, 'list_some_topics', 'stoked-keyword-656')
-  OptionParser.new do |opts|
-    opts.on('--server_host SERVER_HOST', 'server hostname') do |v|
-      args.host = v
-    end
-    opts.on('--server_port SERVER_PORT', 'server port') do |v|
-      args.port = v
-    end
-
-    # instance_methods(false) gives only the methods defined in that class.
-    scenes = NamedActions.instance_methods(false).map { |t| t.to_s }
-    scene_list = scenes.join(',')
-    opts.on("--action CODE", scenes, {}, 'pick a demo action',
-            "  (#{scene_list})") do |v|
-      args.action = v
-    end
-
-    # Set the remaining values.
-    %w(project_id topic_name sub_name).each do |o|
-      opts.on("--#{o} VALUE", "#{o}") do |v|
-        args[o] = v
-      end
-    end
-  end.parse!
-  _check_args(args)
-end
-
-def _check_args(args)
-  %w(host port action).each do |a|
-    if args[a].nil?
-      raise OptionParser::MissingArgument.new("please specify --#{a}")
-    end
-  end
-  args
-end
-
-def main
-  args = parse_args
-  pub, sub = publisher_stub(args), subscriber_stub(args)
-  NamedActions.new(pub, sub, args).method(args.action).call
-end
-
-main