StandardOutput=journal+console

      [Install]
      WantedBy=kubernetes.target

  - path: /etc/systemd/system/kube-node-configuration.service
    permissions: 0644
    owner: root
    content: |
      [Unit]
      Description=Configure kubernetes node
      After=kube-node-installation.service

      [Service]
      Type=oneshot
      RemainAfterExit=yes

    }

    /**
     * Visits the "post-execution" nodes of this node. These nodes should be treated as though they also produce the outputs or
     * results of this node. That is, all nodes that depend on this node should also depend on these nodes. This method is called when
     * this node has executed successfully and before any of its dependents are started, allowing some work of this node to be dynamically split

// node in a single-stack cluster, or a dual-stack pair of IPs in a dual-stack cluster
// (for nodes that actually have dual-stack IPs). Among other things, the IPs returned
// from this function are used as the `.status.PodIPs` values for host-network pods on the
// node, and the first IP is used as the `.status.HostIP` for all pods on the node.
func GetNodeHostIPs(node *v1.Node) ([]net.IP, error) {

			},
		},
	}

	for _, tweak := range tweaks {
		tweak(node)
	}

	return node
}

func setNodeIPAddress(addr string) tweak {
	return func(node *api.Node) {
		node.Status.Addresses = []api.NodeAddress{
			{Type: api.NodeInternalIP, Address: addr},
		}
	}
}

func setNodeDaemonEndpoint(port int32) tweak {
	return func(node *api.Node) {
		node.Status.DaemonEndpoints = api.NodeDaemonEndpoints{

			newNode:      addTaintsToNode(testutil.NewNode("node1"), "testTaint1", "taint1", []int{1}),
			expectPatch:  true,
			expectDelete: true,
		},
		{
			description: "new pod2 created on tainted Node",
			pods: []corev1.Pod{
				*testutil.NewPod("pod1", "node1"),
			},
			prevPod:      nil,
			newPod:       testutil.NewPod("pod2", "node1"),
			oldNode:      testutil.NewNode("node1"),

Output Operation::output(int32_t i) const {
  CHECK_NOTNULL(node_);
  CHECK_GE(i, 0);
  CHECK_LT(i, node_->num_outputs());
  return Output(node_, i);
}

uint64 Operation::hash(int32_t index) const {
  return ::tensorflow::Hash64(reinterpret_cast<const char*>(&node_),
                              sizeof(Node*), index);
}

Operation::Inputs Operation::GetInputs(Node* node) {
  Operation::Inputs inputs;
  if (node != nullptr) {

		PathPrepend: "/proxy/node/node1:10250",
	}
	testTransport2 := &Transport{
		Scheme:      "https",
		Host:        "foo.com",
		PathPrepend: "/proxy/node/node1:8080",
	}
	emptyHostTransport := &Transport{
		Scheme:      "https",
		PathPrepend: "/proxy/node/node1:10250",
	}
	emptySchemeTransport := &Transport{
		Host:        "foo.com",
		PathPrepend: "/proxy/node/node1:10250",
	}

			mode:      SyncFromCloud,
			node:      nodeWithCIDRRange,
			events:    []fakeEvent{{"node1", "CloudCIDRAllocatorInvalidMode"}},
			wantError: true,
		},
		{
			desc: "update alias from node",
			mode: SyncFromCluster,
			node: nodeWithCIDRRange,
			// XXX/bowei -- validation
		},
		{
			desc: "update node from alias",
			mode: SyncFromCloud,
			node: nodeWithoutCIDRRange,

// OnNodeAdd is a handler for Node creates.
func (n *NodeEligibleHandler) OnNodeAdd(node *v1.Node) { n.HealthServer.SyncNode(node) }

// OnNodeUpdate is a handler for Node updates.
func (n *NodeEligibleHandler) OnNodeUpdate(_, node *v1.Node) { n.HealthServer.SyncNode(node) }

// OnNodeDelete is a handler for Node deletes.
func (n *NodeEligibleHandler) OnNodeDelete(node *v1.Node) { n.HealthServer.SyncNode(node) }

    topology.kubernetes.io/region: us-central1
    topology.kubernetes.io/zone: us-central1-b
    kubernetes.io/hostname: node-default-pool-something
  name: node-default-pool-something
  resourceVersion: "211582541"
  selfLink: /api/v1/nodes/node-default-pool-something
  uid: 0c24d0e1-a265-11e9-abe4-42010a80026b
spec:
  podCIDR: 10.0.0.1/24
  providerID: some-provider-id-of-some-sort
status: