File Coverage

blib/lib/Net/NodeTransformator.pm

Criterion	Covered	Total	%
statement	30	108	27.7
branch	0	28	0.0
condition	0	20	0.0
subroutine	10	24	41.6
pod	10	10	100.0
total	50	190	26.3

package Net::NodeTransformator;
# ABSTRACT: interface to node transformator

use strict;
use warnings;
use AnyEvent;
use AnyEvent::Handle;
use AnyEvent::Socket;
use AnyEvent::Proc 0.101;
use Try::Tiny;
use Env::Path;
use File::Temp qw(tempdir);
use POSIX qw(getcwd);

our $VERSION = '0.103'; # VERSION


sub new {
	my ($class, $hostport) = @_;
	if ($hostport !~ m{:}) {
		if ($hostport =~ m{^\d+$}) {
			$hostport = "localhost:$hostport";
		} else {
			$hostport = "unix/:$hostport";
		}
	}
	my ($host, $port) = parse_hostport($hostport);
	if ($host eq 'unix/' and $port !~ m{^/}) {
		$port = getcwd.'/'.$port;
	}
	bless {
		host => $host,
		port => $port,
	} => ref $class || $class;
}


sub standalone {
	my ($class, $hostport) = @_;

	my $bin = 'transformator';
	my ($path) = Env::Path->PATH->Whence($bin);

	unless ($hostport) {
		my $tmpdir = tempdir(CLEANUP => 1);
		$hostport = "$tmpdir/~sock";
	}

	my $errstr;

	my $ok = 0;

	my $server = AnyEvent::Proc->new(
		bin => $path,
		args => [ $hostport ],
		rtimeout => 10,
		errstr => \$errstr,
		on_rtimeout => sub { shift->kill; $ok = 0 },
	);

	while (local $_ = $server->readline) {
		AE::log debug => $_;
		if (/server bound/) {
			$ok = 1;
			last;
		}
	}

	AE::log error => $errstr if $errstr;

	$server->stop_rtimeout;

	unless ($ok) {
		$server->fire_and_kill(10);
		AE::log fatal => 'standalone service not started';
		return undef;
	} else {
		my $client = $class->new($hostport);
		$client->{_server} = $server;
		return $client;
	}
}


sub cleanup {
	my ($self) = @_;
	if (exists $self->{_server}) {
		my $server = delete $self->{_server};
		$server->fire_and_kill(10);
	} else {
		AE::log note => "$self->cleanup called when no standalone server active";
	}

}


sub transform_cv($%) {
	my ($self, %options) = @_;

	my $cv = AE::cv;

	my $err = sub {
		$options{on_error}->(@_);
		$cv->send(undef);
	};

	my $host = $self->{host};
	my $port = $self->{port};

	tcp_connect ($host, $port, sub {
		return $err->("Connect to $host:$port failed: $!") unless @_;
		my ($fh) = @_;
		my $AEH;
		$AEH = AnyEvent::Handle->new(
			fh => $fh,
			on_error => sub {
				my ($handle, $fatal, $message) = @_;
				$handle->destroy;
				$err->("Socket error: $message");
			},
			on_eof => sub {
				$AEH->destroy;
			},
		);
		$AEH->push_read(cbor => sub {
			my $answer = $_[1];
			if (defined $answer and ref $answer eq 'HASH') {
				if (exists $answer->{error}) {
					$err->("Service error: ".$answer->{error});
				} elsif (exists $answer->{result}) {
					$cv->send($answer->{result});
				} else {
					$err->("Something is wrong: no result and no error");
				}
			} else {
				$err->("No answer");
			}
		});
		$AEH->push_write(cbor => [ $options{engine}, $options{input}, $options{data} || {} ]);
	});
	$cv;
}


sub transform($$$;$) {
	my ($self, $engine, $input, $data) = @_;
	my $error;
	my $result = $self->transform_cv(
		on_error => sub { $error = shift },
		engine => $engine,
		input => $input,
		data => $data,
	)->recv;
	return $result if defined $result and not defined $error and not ref $result;
	if (not defined $result and defined $error) {
		AE::log error => $error;
	} else {
		AE::log error => "Something is wrong: $@";
	}
}


sub jade            ($$;$) { shift->transform(jade         => @_) }


sub coffeescript    ($$;$) { shift->transform(coffeescript => @_) }


sub minify_html     ($$;$) { shift->transform(minify_html  => @_) }


sub minify_css      ($$;$) { shift->transform(minify_css   => @_) }


sub minify_js       ($$;$) { shift->transform(minify_js    => @_) }

1;

__END__