view release on metacpan or  search on metacpan

lib/Chef/Header.pm  view on Meta::CPAN

=over

=item  Method( $Method )

set internally to either 'GET' or 'POST'

=item HashedPath ( $path )

calcualtes hash of end point for chef

=item XOpsContentHash ( $content )

calculdates hash of the content

=item XOpsUserId ( $class->name )

initialized user-id field sets to the user_id or client-name.

=item Host( $server )

initialized Host parameter of UA to chef server

=item XChefVersion ( $chef_server_version )

initialized Chef server Version to use

=item XOpsSign( $XOpsSign )

initializes to 'version=1.0' as specified in the chef API documentation.

=item XOpsTimestamp

initialized the request timestamp for http request to now

=item header

returns all the headers 

=item hash

returns hash of all the headers , initialized so far.

=item header_to_string

return a comma seperated list of keys and values of the header

=back 

=cut
  
  sub header {
    my $class = shift;
    my $param = {@_};
    
    package Chef::Header::header;

    use parent -norequire,qw { Chef::Header };
       
    my $self = new Chef::Header::header();

    $self->_chef_encoder( new Chef::Encoder( 'private_key_file'  => $class->private_key ) );
    
    $self->Method          ($param->{'Method'         });
    $self->HashedPath      ($param->{'Path'           });
    $self->XOpsContentHash ($param->{'Content'        });
    #$self->XOpsTimestamp   ($param->{'X-Ops-Timestamp'  });
    $self->XOpsUserId      ($class->name               );
  
    #default_values
    #$self->Accept          ($param->{'Accept'         });
    $self->Host            ($class->server             );
    $self->XChefVersion    ($class->chef_version       );
    $self->XOpsSign        ($param->{'XOpsSign'       });
    $self->Accept          ($param->{'Accept'         });    

    return $self;
  
  	 sub _chef_encoder {
		my $self = shift;
		my $obj  = shift;
		       $self->{'header_chef_encoder'} = $obj if defined $obj;
		return $self->{'header_chef_encoder'};
  	 }
  	 
    sub XOpsSign
    {
      my ($self, $x_ops_sign) = (@_);
             $self->header->{'X-Ops-Sign'} = $x_ops_sign if defined $x_ops_sign;
             $self->header->{'X-Ops-Sign'} = 'version=1.0;' unless 
     defined $self->header->{'X-Ops-Sign'};
      return $self->header->{'X-Ops-Sign'};  
    }

    sub XChefVersion
    {
      my ($self, $x_chef_version) = (@_);
             $self->header->{'X-Chef-Version'} = $x_chef_version if defined $x_chef_version;
      return $self->header->{'X-Chef-Version'};  
    }

    sub Host 
    {
      my ($self, $host) = (@_);
      if( defined ($host) ){
        $host =~ s/^(http|https):\/\/(.*)/$2/;
        $self->header->{'Host'} = $host;
      }
      return $self->header->{'Host'};  
    }

    sub Accept 
    {
      my ($self, $accept) = (@_);
             $self->header->{'Accept'} = $method if defined $accept;
             $self->header->{'Accept'} = 'application/json' unless 
     defined $self->header->{'Accept'};           
      return $self->header->{'Accept'};  
    }

    sub Method 
    {