CPAN::Groonga

equest(GET => $self->url . $namespace_path));
    if ($res->is_success) {
        my $ns = $self->json->decode($res->content);

        # Somewhere between Kubernetes 1.2 and 1.5, the self link for na

        $self->json->encode({ 
            metadata => {
                name => $namespace
            }
        }),
    ));

    if ($res->is_success) {
        my $ns = $self->json->decode($res->c

t($self->create_request(GET => $uri));
    if ($res->is_success) {
        my $node_list = $self->json->decode($res->content);
        my (@nodes) = ();
        foreach my $node (@{$node_list->{items}

st($self->create_request(GET => $uri));
    if ($res->is_success) {
        my $set_list = $self->json->decode($res->content);
        my @sets;
        foreach my $rs (@{$set_list->{items}}) {
      

        # Handle serializing data
            if (uc($data->{$key}{type}) eq 'JSON') {
                $value = $self->json->encode($data->{$key}{value});
            }
            elsif (uc($data->{$

s "type" and "value".

Valid types are "JSON", "YAML" or "String" (anything other that "JSON" or
"YAML") will be assumed to be of type "String". If either "JSON" or "YAML" the
"value" will be serializ

    ssh-public-key => '/home/dave/.ssh/id_rsa.pub',
    super-secret-data => {
        type  => 'JSON',
        value => { username => 'Dave', password => 'Imnottelling' },
    }
  });

=head1 AUTHOR

st($self->create_request(GET => $uri));
    if ($res->is_success) {
        my $pod_list = $self->json->decode($res->content);
        my (@pods) = ();
        foreach my $pod (@{$pod_list->{items}}) 

th 'Net::Kubernetes::Role::ResourceCatalog';

requires 'ua';
requires 'create_request';
requires 'json';


sub list_pods {
    my $self = shift;
    return $self->_retrieve_list('Pod', @_);
}


sub li

elf->create_request(GET => $uri));
    if ($res->is_success) {
        my $resource_list = $self->json->decode($res->content);

        my @resources;
        foreach my $resource (@{$resource_list->{

 the REST api

use Moose::Role;
require LWP::UserAgent;
require HTTP::Request;
use JSON::MaybeXS;
require Cpanel::JSON::XS;
require URI;
use MIME::Base64;
use syntax "try";

has url => (
    is       

tr',
    required => 0
);

has 'json' => (
    is       => 'ro',
    isa      => JSON::MaybeXS::JSON,
    required => 1,
    lazy     => 1,
    builder  => '_build_json',
);

has 'ssl_cert_file' => (

    unless ($res->is_success) {
        my $message;
        try {
            my $obj = $self->json->decode($res->content);
            $message = $obj->{message};
        }
        catch($e) {
   

th 'Net::Kubernetes::Role::ResourceFactory';

requires 'ua';
requires 'create_request';
requires 'json';
requires 'namespace';


sub create_from_file {
    my ($self, $file) = @_;
    if (!-f $file) {

a?ml$/i) {
        $object = YAML::XS::LoadFile($file);
    }
    else {
        $object = $self->json->decode(scalar(read_file($file)));
    }

    return $self->create($object);
}

sub create {
    

lue as 1 or 0 which json does not switch back to
    # true or false. This is not JSON's fault, but I'm not
    # sure just now how I want to solve it.
    my $content = $self->json->encode($object);

st($self->create_request(GET => $uri));
    if ($res->is_success) {
        my $pod_list = $self->json->decode($res->content);
        my (@pods) = ();
        foreach my $pod (@{$pod_list->{items}}) 

elf->create_request(GET => $self->path));
    if ($res->is_success) {
        my ($data) = $self->json->decode($res->content);
        $self->status($data->{status});
        return 1;
    }
    retur

eturn $self->create_resource_object($self->json->decode($res->content));
    }
    else {
        my $message;
        try {
            my $obj = $self->json->decode($res->content);
            $mess

request(
        $self->create_request(
            PUT => $self->path,
            undef, $self->json->encode($self->as_hashref)
        )
    );
    if ($res->is_success) {
        return 1;
    }