Skip to main content
OnCommand Workflow Automation 5.1
Se proporciona el idioma español mediante traducción automática para su comodidad. En caso de alguna inconsistencia, el inglés precede al español.

Consideraciones que tener en cuenta al convertir comandos de PowerShell en Perl

Colaboradores
PDF

Debe tener en cuenta diferentes consideraciones al convertir los comandos de PowerShell en Perl, porque PowerShell y Perl tienen diferentes funcionalidades.

Tipos de entrada de comandos

OnCommand Workflow Automation (WFA) permite a los diseñadores de flujos de trabajo utilizar cabinas y hash como entrada para el comando al definir un comando. Estos tipos de entrada no se pueden utilizar cuando el comando se define usando Perl. Si desea que un comando Perl acepte entradas array y hash, puede definir la entrada como una cadena en el diseñador. La definición de comandos puede analizar la entrada, que se pasa para crear una matriz o hash según sea necesario. La descripción de la entrada describe el formato en el que se espera la entrada.

my @input_as_array  = split(',', $InputString); #Parse the input string of format val1,val2 into an array

my %input_as_hash = split /[;=]/, $InputString; #Parse the input string of format key1=val1;key2=val2 into a hash.

Declaración de PowerShell

Los siguientes ejemplos muestran cómo puede pasar una entrada de cabina a PowerShell y Perl. En los ejemplos se describe la entrada CronMonth, que especifica el mes en el que está programado que se ejecute el trabajo cron. Los valores válidos son números enteros -1 a 11. Un valor de -1 indica que la programación se ejecuta cada mes. Cualquier otro valor denota un mes específico, siendo 0 enero y 11 diciembre.

[parameter(Mandatory=$false, HelpMessage="Months in which the schedule executes. This is a comma separated list of values from 0 through 11. Value -1 means all months.")]
  [ValidateRange(-1, 11)]
  [array]$CronMonths,

Instrucción Perl

GetOptions(
    "Cluster=s"         => \$Cluster,
    "ScheduleName=s"    => \$ScheduleName,
    "Type=s"            => \$Type,
    "CronMonths=s"      => \$CronMonths,
) or die 'Illegal command parameters\n';

sub get_cron_months {
    return get_cron_input_hash('CronMonths', $CronMonths, 'cron-month', -1,
        11);
}

sub get_cron_input_hash {
    my $input_name   = shift;
    my $input_value  = shift;
    my $zapi_element = shift;
    my $low          = shift;
    my $high         = shift;
    my $exclude      = shift;

    if (!defined $input_value) {
        return undef;
    }

    my @values = split(',', $input_value);

    foreach my $val (@values) {
        if ($val !~ /^[+-]?\d+$/) {
            die
                "Invalid value '$input_value' for $input_name: $val must be an integer.\n";
        }
        if ($val < $low || $val > $high) {
            die
                "Invalid value '$input_value' for $input_name: $val must be from $low to $high.\n";
        }
        if (defined $exclude && $val == $exclude) {
            die
                "Invalid value '$input_value' for $input_name: $val is not valid.\n";
        }
    }
    # do something
}

Definición de comandos

Una expresión de una línea en PowerShell que use un operador de canalización puede tener que ampliarse a múltiples bloques de sentencias en Perl para lograr la misma funcionalidad. En la siguiente tabla se muestra un ejemplo de uno de los comandos de espera.

Declaración de PowerShell Instrucción Perl 
# Get the latest job which moves the specified volume to the specified
 aggregate.
$job = Get-NcJob -Query $query

where {$_.JobDescription -eq "Split" + $VolumeCloneName}

Select-Object -First 1 ----

 
my $result = $server->job_get_iter(
	'query' => {'job-type' => 'VOL_CLONE_SPLIT'},
	'desired-attributes' => {
		'job-type' => '',
		'job-description' => '',
		'job-progress' => '',
		'job-state' => ''
	}
);
my @jobarray;
for my $job (@{ $result->{'attributes-list'}})
{
	my $description = $job->{'job-description'};
	if($description =~ /$VolumeCloneName/)
	{
		push(@jobarray, $job)
	}
}