Padre::Sync - Utility functions for handling remote Configuration Syncing

  my $manager = Padre->ide->config_sync;

package Padre::Sync;

use 5.008;
use strict;
use warnings;
use Carp           ();
use File::Spec     ();
use Scalar::Util   ();
use Params::Util   ();
use JSON::XS       ();
use LWP::UserAgent ();
use HTTP::Cookies  ();
use HTTP::Request::Common qw/GET POST DELETE/;
use Padre::Util     ();
use Padre::Current  ();
use Padre::Constant ();

our $VERSION = '0.86';





#####################################################################
# Constructor and Accessors

sub new {
	my $class = shift;
	my $ide = Params::Util::_INSTANCE( shift, 'Padre' );
	unless ($ide) {
		Carp::croak("Creation of a Padre::Sync without a Padre not possible");
	}

	# Create the useragent.
	# We need this to handle login actions.
	# Save cookies for state management from Padre session to session
	# is this even wanted? remove at padre close?
	my $ua = LWP::UserAgent->new;
	push @{ $ua->requests_redirectable }, 'POST';
	$ua->timeout(2);
	$ua->cookie_jar(
		HTTP::Cookies->new(
			file => File::Spec->catfile(
				Padre::Constant::CONFIG_DIR,
				'lwp_cookies.dat',
			),
			autosave => 1,
		)
	);

	my $self = bless {
		ide   => $ide,
		state => 'not_logged_in',
		ua    => $ua,
		json  => JSON::XS->new,
		@_,
	}, $class;

	return $self;
}

sub main {
	$_[0]->{ide}->wx->main;
}

sub config {
	$_[0]->{ide}->config;
}

sub ua {
	$_[0]->{ua};
}

sub register {
	my $self   = shift;
	my $params = shift;
	my $server = $self->config->config_sync_server;

	return 'Registration Failure'      unless %$params;
	return 'Failure: no server found.' unless $server;

	if ( $self->{state} ne 'not_logged_in' ) {
		return 'Failure: cannot register account, user already logged in.';
	}

	# this crashes if server is unavailable. FIXME
	my $resp = $self->ua->request(
		POST "$server/register",
		'Content-Type' => 'application/json',
		'Content'      => $self->{json}->encode($params),
	);
	if ( $resp->code == 200 ) {
		return 'Account registered successfully. Please log in.';
	}

	my $h = $self->{json}->decode( $resp->content );

	return "Registration Failure: $h->{error}" if $h->{error};
	return "Registration failure.";
}

sub login {
	my $self   = shift;
	my $params = [@_];
	my $server = $self->config->config_sync_server;

	return 'Failure: no server found.' unless $server;

	if ( $self->{state} ne 'not_logged_in' ) {
		return 'Failure: cannot log in, user already logged in.';
	}

	my $resp = $self->ua->request( POST "$server/login", $params );

	if ( $resp->content !~ /Wrong username or password/i and $resp->code == 200 ) {
		$self->{state} = 'logged_in';
		return 'Logged in successfully.';
	}

	return 'Login Failure.';
}

sub logout {
	my $self   = shift;
	my $server = $self->config->config_sync_server;

	return 'Failure: no server found.' if not $server;

	if ( $self->{state} ne 'logged_in' ) {
		return 'Failure: cannot logout, user not logged in.';
	}

	my $resp = $self->ua->request( GET "$server/logout" );

	if ( $resp->code == 200 ) {
		$self->{state} = 'not_logged_in';
		return 'Logged out successfully.';
	}

	return 'Failed to log out.';
}

sub server_delete {
	my $self   = shift;
	my $server = $self->config->config_sync_server;

	return 'Failure: no server found.' if not $server;

	if ( $self->{state} ne 'logged_in' ) {
		return 'Failure: user not logged in.';
	}

	my $resp = $self->ua->request( DELETE "$server/user/config" );

	if ( $resp->code == 200 ) {
		return 'Configuration deleted successfully.';
	}

	return 'Failed to delete serverside configuration file.';

}

sub local_to_server {
	my $self   = shift;
	my $server = $self->config->config_sync_server;

	return 'Failure: no server found.' if not $server;

	if ( $self->{state} ne 'logged_in' ) {
		return 'Failure: user not logged in.';
	}

	my $conf = $self->config->human;

	# theres gotta be a better way to do this
	my %h;
	for my $k ( keys %$conf ) {
		$h{$k} = $conf->{$k};
	}

	my $resp = $self->ua->request(
		POST "$server/user/config",
		'Content-Type' => 'application/json',
		'Content'      => $self->{json}->encode( \%h ),
	);
	if ( $resp->code == 200 ) {
		return 'Configuration uploaded successfully.';
	}

	return 'Failed to upload configuration file to server.';
}

sub server_to_local {
	my $self   = shift;
	my $config = $self->config;
	my $server = $config->config_sync_server;

	return 'Failure: no server found.' if not $server;

	if ( $self->{state} ne 'logged_in' ) {
		return 'Failure: user not logged in.';
	}

	my $resp = $self->ua->request( GET "$server/user/config", 'Accept' => 'application/json' );

	my $c;
	eval { $c = $self->{json}->decode( $resp->content ); };
	if ($@) {
		return 'Failed to deserialize serverside configuration.';
	}

	# apply each setting to the global config. should only be HUMAN settings
	delete $c->{Version};
	delete $c->{version};
	for my $key ( keys %$c ) {
		$config->apply( $key, $c->{$key} );
	}
	$config->apply( main_singleinstance => 1 );
	$config->write;

	if ( $resp->code == 200 ) {
		return 'Configuration downloaded and applied successfully.';
	}

	return 'Failed to download serverside configuration file to local Padre instance.';
}

sub english_status {
	my $self = shift;
	return 'User is not currently logged into the system.' if $self->{state} eq 'not_logged_in';
	return 'User is currently logged into the system.'     if $self->{state} eq 'logged_in';
	return "State unknown: $self->{state}";
}

1;

# Copyright 2008-2011 The Padre development team as listed in Padre.pm.
# LICENSE
# This program is free software; you can redistribute it and/or
# modify it under the same terms as Perl 5 itself.