►
Description
Crescendo is a recently released PowerShell module from the PowerShell team. It allows you to create PowerShell modules and cmdlets for native commands that don’t play nice with PowerShell today.
Programs like kubectl, ipconfig, docker, etc become PowerShell capable; giving you the full potential of PowerShell to streamline your workflows. Simple string output becomes object data in PowerShell, allowing you to use all the goodness you love about PowerShell. Stephen Valdinger dives into how Crescendo works, and shows how he used it to turn some of the cmd line tools he uses into PowerShell cmdlets.
Speaker Bio:
Stephen Valdinger (aka “steviecoaster” across social media) manages the Customer Experience for Chocolatey Software. He spends his days ensuring documentation, end user experience, and tools meet customers and users where they are in their automation journey. “Stevie” sometimes doesn’t sleep on the weekends when someone gives him an idea on a Friday afternoon that he can’t let go of.
A
Hey
everybody
welcome
to
the
may
4th
meeting
of
the
research
triangle-
powershell
user
group.
My
name
is
mike
kanakis
and
tonight
we
are
happy
to
have
stevie
valdinger,
also
known
as
stevie
coaster
of
chocolatey
fame
with
us
to
be
doing
a
demo
on
the
new
module
from
the
powershell
team
called
crescendo.
B
One
of
the
links
on
the
readme
goes
out
to
the
documentation
which
is
found
on
docs.microsoft.com
big
long
link.
So
I'm
not
going
to
worry
about
telling
it
to
you.
There
just
go
to
the
github
repository
it'll.
Take
you
right
to
it.
You've
got
your
overview
and
then
you're
getting
started
section
here.
So
it
teaches
you
how
to
install
crescendo
basic
information
about
using
it
the
different
mod,
the
different
commandlets
that
are
inside
of
the
module,
etc,
etc,
etc.
B
We're
not
going
to
spend
a
great
amount
of
time
going
through
the
docks
and
and
the
different
commandlets
that
are
available
via
the
the
module
I'm
going
to
spend
a
whole
lot
of
time,
walking
through
the
json
and
explaining
to
you
kind
of
the
point
and
how
you
can
modify
the
json
right
to
json
and
get
the
working
code
out
of
it
at
the
at
the
end.
So
really
to
take
a
quick
step
back
and
kind
of
explain
the
point
of
this
thing.
Right.
B
A
B
Crescendo
and
we
can
demonstrate
it
relatively
easily
on
the
command
line
here,
so
it
takes
a
native
command
that
ships,
perhaps
it
ships
on
box
on
your
mac
or
on
your
windows
machine
or
on
your
linux
machine.
I
think
things
like
ping.xi
or
ipconfig.exe
or
netstat
or
whatever,
that
native
command
is
that
returns
string
output,
that's
really
ugly,
really
hard
to
deal
with
crescendo
takes
that
native
command
and
the
output
and
wraps
it
in
powershell.
B
To
give
you
a
powershell
command
that
you
run
and
gives
you
a
powershell
object
back
as
the
output,
which
enables
you
to
do
all
the
cool
fun
things
that
you'd
like
to
do
with
powershell,
to
use
that
native
tool,
for
example,
if
I
run
vagrant
global
status
and
we'll
get
to
the
meat
and
potatoes
and
make
this
really
power
shelly
in
a
few
minutes.
But
this
is
the
native
command
for
getting
the
vagrant
status
of
machines
that
are
currently
provisioned
on
your
on
your
workstation
here,
ta-da,
nice
and
nice
and
simple.
B
But
it's
really
ugly,
that
sucks
to
have
to
figure
that
out
and
automate
it
and
be
able
to
do
other
things
with
it.
The
same
way
that
you
would
expect
to
do
with
powershell,
you
would
want
to
do
things
like
pipe
it
to
where
object
or
group
object
or
select
object
or
for
each
object
or
whatever
you
want
to
do.
It's
much
easier
to
do
those
things
when
it's
a
powershell
object
as
opposed
to
string
data
and
that's
where
crescendo
kind
of
kind
of
comes
to
the
rescue.
A
B
C
A
So
I
I
asked
you
that
question
knowing
the
answer,
so
what
I
was
going
to
try
to
convey
to
people
is
that
crescendo
allows
you
to
do
you
do
a
little
bit
of
work
up
front,
setting
up
basically
a
matrix
that
when
this
command
is
run,
do
this
and
then
what
it
does
is
it
produces
some
code
for
you
that
you
can
then
use
going
forward
right?
That's
the
yeah
yeah.
B
Yeah,
so
here's
all
the
different
things
that
you
can
do
to
and
to
help
you
create
a
crescendo
module
new
crescendo
command
will
scaffold
out
part
of
the
json.
It
doesn't
do
all
of
the
json
that
you
would
want,
and
new
parameter
info
info
gives
you
part
of
the
json
that
you
would
want,
but
probably
not
all
of
the
json
that
you
would
want
so
being
that
it
just
shipped
and
it's
kind
of
brand
new
and
not
a
lot
of
people
are
using
it.
B
A
So,
let's
jump
ahead
for
a
second
perry,
has
perry
harris
just
asked
a
fantastic
question
in
chat,
which
is:
is
the
code
that's
generated
only
usable
on
this
box
or
can
use
it
on
other
systems?
And
so
there's
a
there's
a
little
bit
of
an
answer
to
that?
But
what
you're
gonna
do?
What
you're
gonna
do
perry
is
you're
gonna
build
some
code
in
in
the
form
of
a
module,
and
then
once
you
have
a
module,
you
can
take
that
module
and
you
can
use
it
on
other
systems.
A
B
Yep
exactly
you
get
a
powershell
module.
What
you
do
with
it
at
that
point
is
up
to
you.
You've
got
the
psm1.
You've
got
the
psd1.
You
can
zip
those
off
and
ship
them
somewhere.
You
can
put
them
in
source
control
that
people
can
clone
and
use.
You
can
publish
them
to
an
internal
nuget
repository,
and
then
you
can
use
install
module
to
install
those
things
if
you're
doing
things
that
way,
which
I
would
recommend
you
do
that,
but
yeah
it's.
It
is
functionally
a
module
at
the
end
of
it.
B
So
you
can
consume
it.
However,
you
want
you
can
share
it.
However,
you
want
so,
let's
dive
into
what
the
json
actually
looks
like
this
is
the
json
file
for
the
openssl
module
that
we're
going
to
be
writing
as
part
of
this
talk
and
I'm
going
to
delete
just
these
two
files.
That
way,
we
can
see
everything
from
start
to
finish
at
the
end
of
it
and
the
json
has
a
schema
associated
with
it.
B
So
the
very
first
line
after
you
open
your
json
file
is
the
schema
declaration
put
that
url
in
and
then
you
start
getting
things
like
syntax
highlighting.
So
we
can
come
in
here
and
we
can
say
now
and
it'll
fill
it
in
and
do
all
those
nice
fun
things
for
you.
So
the
schema
is
really
really
great
and
it
holds
your
hand
a
lot
and
that's
why
I
I
don't
get
scared
at
editing
this
json,
because
the
schema
is
so
good.
The
intellisense
is
so
good.
It
kind
of
helps
me
know
what
I
want.
B
Oh
excuse
me
so
in
this
I'm
fully
qualifying
the
path
to
the
native
command
that
I
want
to
wrap.
You
don't
have
to.
I
just.
I
have
a
habit
of
fully
qualifying
things
just
so.
I
can
ensure
that
on
my
system,
it's
going
to
work,
but
if
you
are
going
to
ship
this
module
and
give
to
other
people,
that's
probably
a
not
great
thing.
So
the
better
thing
in
that
situation
would
probably
be
to
just
call
the
native
command
directly
and
rely
on
it
being
on
the
path
of
whatever
target
system.
B
It's
going
to
run
on
that
will
make
it
safe
if
somebody
like
installs
openssl,
to
a
different
directory
than
the
default
that
the
installer
gives
it
or
somebody
is
running.
A
windows,
machine
and
open
ssl
is
installed
in
program
files
and
then
you
give
it
to
somebody
who's
on
a
mac
and
is
in
user
bin.
B
B
B
B
This
is
just
a
string,
it's
not
an
array,
so
no,
it
wouldn't
be
a
it
wouldn't
be
a
multi-path
thing.
Now,
if
you
do
so
this,
it
doesn't
matter
as
long
as
the
path
is
correct,
because
every
system
has
a
path
like.
I
can
open
up
my
terminal
and
type
open
ssl
and
it
drops
me
into
open
ssl
and
I
can
do
the
same
thing
on
on
windows.
But,
yes,
I
am
looking
at
the
chat
now
and
it
would
not
support
side
by
side
as
as
it
stands.
C
C
A
So
so
sean
sort
of
beat
me
to
the
punch
here
I
was
going
to
say
essentially
that
so
what
we're
working
with
today,
the
crescendo
module
is
actual
blessed
microsoft
code,
but
I
don't
think
that
they
would
call
it
feature
complete.
I
think
they
have
a
working
module.
That
can
do
some
really
great
things
which
steve
is
going
to
show
you
tonight,
but
I
think
also
part
of
the
thing
here
is,
as
this
gets
some
uptake
with
the
community
there's
some
expectation.
Just
like
that
question:
hey.
We
didn't
think
of
that
scenario.
A
Maybe
we
can
add
in
some
code
to
handle
those
different
types
of
things,
so
we
may
not
be
able
to
answer
every
question
or
there
may
not
be
code
available
to
handle
every
scenario
that
you
think
of
today.
But
the
point
that
sean
is
making
is
that
this
is
an
open
source
tool.
It's
community
driven
microsoft,
is
sort
of
leading
that
charge
and
writing
the
code,
but
the
ideas
that
come
from
the
community
are
definitely
considered
and
tried
to
be
incorporated
into
this
module
so
head
to
the
github
repo
open,
an
issue
with
your
ideas.
B
B
So
in
this
example,
I'm
going
to
convert
to
pfx
certificate.
So
when
we
call
it
on
the
command
line,
it's
going
to
be
literally
convert
to
pfx
certificate
is
what
we'll
call
once
we
have
the
module
done
and
off
original
command
elements.
So
sometimes
a
native
command
has
sub
commands
before
you
get
to
parameters.
So,
for
example,
if
you
were
to
do
like
ping
dash
4
that
would
be
native
command
and
a
parameter,
whereas
something
like
openssl
can
do
a
whole
bunch
of
stuff
and
it
handles
doing
that
whole
bunch
of
stuff
via
sub
commands.
B
So
in
the
case
of
converting
some
kind
of
certificate
to
a
pfx
certificate,
the
sub
command
for
that
is
openssl,
pkcs12
and
then
your
ends
and
your
outs
and
your
keys
and
etc,
etc,
etc.
All
of
your
parameters
come
after
that.
So
what
the
original
command
elements
array
does
is
appends
all
of
those
sub
command
things
to
the
command.
B
That
way,
when
you
define
your
parameters,
you
are
actually
defining
the
powershell
equivalent
to
whatever
the
native
command
parameter
is,
and
I've
found
that
you
can
cheat
this
a
little
bit
and
have
multiple
command
elements
to
kind
of
lock
things
down
and
make
it
simpler
for
writing
very
specific
commandlets.
Instead
of
having
one
commandlet
that
does
several
things
kind
of
okay,
you
can
have
one
commandlet.
That
does
one
thing
well,
the
same
way,
you
should
have
a
script.
That
does
one
thing
and
one
thing
well
and
then
hands
it
off
to
another
script.
B
The
name
of
the
parameter
will
be
the
name
of
the
powershell
equivalent,
so
dash
export.
In
this
case,
the
original
name
is
the
parameter
from
the
native
command.
So
if
that's
dash
export
as
it
is
here
or
some
native
commands
are
very
like
dash
dash,
whatever
the
the
command
happens
to
be
so
whatever
you
typically
pass
to,
the
native
command
is
the
original
name
in
this
example,
and
then
what
kind
of
powershell
parameter
do
you
want
this
to
be?
B
So,
in
this
case,
we're
going
to
make
this
a
switch
and
we're
going
to
say
this
is
a
mandatory
parameter.
You
must
pass
export
to
this
command
now.
I
probably
could
have
come
up
here
and
gone
like
this
and
said
export
it
eliminated
this
parameter,
because
I
it's
mandatory
that
you
pass
a
switch.
That
seems
really
really
silly
to
do
that.
The
switch
is
either
on
or
it's
off.
Why
force
it
to
always
be
on
that
the
ux
of
that
is
kind
of
silly.
B
B
B
B
B
B
So
what
else
do
we
have
here?
We
have
our
n,
which
is
going
to
be
the
thing
that
we're
converting
we're
going
to
have
the
private
key,
that's
associated
with
that
certificate
that
we
want
to
convert,
and
then
we
have
the
pfx
file
that
we're
going
to
be
producing
and
then
the
password
for
that
pfx
file
in
terms
of
importing
it
onto
the
system.
Now
this
is
kind
of
lazy
and
not
super
well
defined,
so
to
showcase
how
good
it
could
be.
B
I've
added
a
few
more
commands
that
use
a
bit
more
of
the
json
schema
to
show
you
just
how
close
to
a
real
powershell
command
like.
If
you
were
to
write
this
all
yourself
crescendo
can
actually
get
you
today,
so
we
still
have
our
verb
in
our
noun.
We
have
convert
from
pen
file
as
the
commandlet
that
we're
going
to
write
here.
We
have
our
description.
We
have
our
usage
statement,
which
has
a
subnaut
synopsis
and
it
has
a
few
more
items
that
that
we
can
do
as
well,
and
I
haven't
really
used
these.
B
C
B
I
had
a
feeling:
that's
what
original
text
was,
but
again
I
haven't
played
with
everything
you
can
do
in
the
schema
yet
so
there
are
some
things
that
I'm
not
familiar
with.
So
what
else
do
we
have
here?
We
have
our
parameters
node
and
our
command
elements.
So
for
this
this
is
an
x509
sub
command
and
we
are
being
very
descriptive
and
saying
hey
for
this.
B
B
You
must
pass
this
because
it's
mandatory
and
this
additional
parameters,
attributes
array,
is
where
things
get
a
little
bit
interesting.
So
these
are
the
strings,
but
you
can
do
all
those
extra
decorators
that
you
could
do
inside
of
a
powershell
command.
So,
for
example,
if
you
were
to
start
defining
commandlet,
binding
and
parameter-
and
you
have
a
parameter-
it's
me
and
did
I
type
that
right,
yeah,
it's
mandatory?
B
B
B
Perfect,
so
that's
what
additional
parameter
attributes
are
for
and
then
again
this
is
going
to
be
a
string.
So
in
this
example
I've
added
this
validate
script,
that's
going
to
say,
hey!
If
somebody
gives
me
a
pen
file,
make
sure
the
extension
actually
is
dot
pem.
If
it's
anything
else
through
an
error,
and
that
gives
me
validation
right
here
early
and
fails
super
early
before
any
code
runs
so
that
they
get
a
good
message
back
and
says:
hey,
because
this
isn't
an
extension
or
isn't
the
correct
extension
then
go.
A
A
B
B
A
The
point
here
is
is
that
this
powershell
team
has
given
us
a
framework
to
take
unstructured
work
in
in
the
form
of
a
commandlet
of
a
program
that
has
some
some
switches
that
return
data.
But
the
data
that
comes
back
is
just
text
and
allows
us
to
build
some
structure
around
it,
so
that
when
the
data
comes
back,
that
text
turns
into
objects
and
then
as
stevie,
let
in
once
it's
an
object
and
once
it's
power
shell
aware
you
get
to
do
all
the
things
that
you
do
in
powershell.
A
My
group
had
a
gentleman
on
about
two
years
ago
who
showed
how
to
do
this
same
process
without
this
for
a
simple
command
line
utility,
and
it
was
a
45
minute
demo
to
figure
out
how
to
do
just
the
basics
and
he
just
barely
got
it
working
and
it
worked.
But
it
was,
I
would
say,
10
times
the
amount
of
work
that
stevie's
putting
in
here
to
get
the
same
sort
of
functionality.
B
Yeah
and
honestly,
once
you
do
play
with
this
schema
once
or
twice
it's
really
friendly,
and
it's
not
that
hard
to
understand
what
you
need,
because
if
you
think
about
it,
when
you're
writing
a
powershell
function,
you
need
a
verb
and
you
need
a
noun
and
you
sure,
as
hell
better
be
writing
comment
based
help
for
your
function,
so
you're
going
to
have
a
description
and
a
synopsis
and
examples
like
you're
not
done
until
you
have
that
stuff.
So.
B
All
that
stuff
exists
in
this
json.
There's
your
description,
there's
your
usage!
Now
it's
a
little
weird
that
usage
has
more
than
one
thing
and
your
synopsis
is
is
inside
it.
However,
once
you're
kind
of
doing
it
once
or
twice
it's
not
too
bad,
and
then
it's
your
parameters,
and
what
do
you
normally
do
with
your
parameters?
B
You
give
them
a
name.
You
decide
whether
they're,
mandatory
or
not.
You
can
do
things
like
parameter
set,
name
stuff,
so
parameter
set
name.
You
might
want
this
to
be
in
a
foo
parameter
set
and
a
bar
parameter
set
and
everything
else
be
in
like
a
default
parameter
set
et,
cetera,
et
cetera.
You
can
do
all
that
stuff
inside
of
this
json,
so
it's
all
there
more
or
less.
It's
just
a
different
format
than
what
you're
used
to
writing.
C
It
puts
that
all
in
the
json
and
then
your
code,
that
does
the
work
of
converting
the
output
to
objects,
is
separate.
So
you
don't
have
to
worry
about
writing
all
the
code
that
does
the
parameter,
handling
and
validation
and
all
that
stuff
it's
defined
here.
So
it
separates
those
into
two
different
files.
B
Right
exactly
what
else
was
I
going
to
point
out?
Oh
on
this
particular
so
skipping
around
functions
just
a
little
bit,
because
we've
kind
of
covered
most
of
the
bits
and
pieces
here
for
new
certificate,
signing
requests.
I've
added
some
examples,
so
there's
an
examples.
Node
here.
That
is
an
array
and
this
particular
node,
there's
only
one
example:
so
command
new
certificate
signing
request.
The
description
which
will
show
up
under
the
example
is
generates
a
csr
with
a
private
key
and
then
the
original
command
is
open,
ssl
and
blah
blah
blah
d.
B
You
get
that
and
what
it
does
is
it
takes
the
original
command.
What
you
have
here
and
it
converts
it
into
the
equivalent
powershell
from
crescendo
when
you
do
get
help
for
that
particular
for
this
particular
function.
Once
we
export
the
the
module
or
import
the
module,
rather
once
it's
built,
and
for
this
one
I've
given
a
couple
of
aliases
for
new
csr
and
just
csr,
I
realized
that
that
might
collide
with
something
from
the
gallery.
B
Maybe
I
just
pulled
the
stuff
out
of
my
butt,
if
I'm
honest,
so
I
have
no
idea
if
this
is
going
to
cause
collisions
with
anything
or
not
long
term,
but
as
a
proof
of
concept
to
prove
a
point.
You
can
do
aliases
high
level
for
the
functions
themselves,
not
just
the
parameters
as
well,
and
that
is
about
it
for
this
particular
json
file.
I'm
not
going
to
save
any
of
the
changes
that
I
made
to
this
one,
but
I
am
going
to
start
building
the
powershell
module.
So
let
me
get
my.
B
C
B
B
B
So
with
that
said,
we
can
see
now
that
we've
got
our
openssl
psd1
psm1
and
those
are
your
bulk
standard,
psd
ones
and
psn
ones.
Only
you
didn't
have
to
lift
a
finger.
It
figured
out
the
functions
to
export,
put
them
all
in
there.
It
did
all
that
work
for
you.
It's
got
the
the
aliases
to
export.
It's
done
everything
you
need
to
make.
This
work
is
done
in
the
psc
one
and
then
the
psm1
it
they
did
write
all
the
powershell
code
for
you
so
full
stop.
You
didn't
write
any
of
this.
B
You
you
had
to
write
a
damn
json
file
and
you
got
a
powershell
module
out
of
it.
So
this
is
what
you
get
yes,
it
looks
probably
different
than
the
way
you
would
write
it.
However,
there's
a
reason
for
it:
it's
because
they're
doing
really
clever
things
to
make
the
native
command
to
powershell
hook.
Work
really
really
really
well,
but
it's
all
it's
all
in
there.
You
didn't
have
to
lift
a
finger
for
this,
so
let's
play
with
it
a
little
bit.
So
if
we
come
over
here
we
can
start
importing
this
model.
A
C
B
So
I
use
when
I'm
building
powershell
modules,
like
outs
like
pure
powershell
modules,
not
something
that
wraps
the
native
command.
I
use
the
tool
called
git
version
and
then
push
tags
to
my
repository
and
git
version,
picks
up
those
tags
and
asserts
the
correct
version
for
the
module
based
on
commit
history
and
the
tags
that
I've
pushed
to
the
repository.
B
And
then
I
have
a
build
step
that
updates
the
module
manifest
with
that
version
number
from
the
output
of
git
version.
So
if
you're
doing
something
in
ci,
where
you've
got
a
native
command,
that
a
team
of
developers
is
working
on
for
your
organization
or
your
company,
and
you
want
to
have
a
powershell
way
of
interacting
with
that
native
command.
For
obvious
reasons,
because
powershell
is
amazing
and
string
data
sucks,
you
could
write
this
json
file
or
give
them
all
the
information
they
need
to
maintain.
C
C
B
B
Yeah
so
he's
defining.
I
think
I've
looked
through
this
actually,
so
he
just
uses
hash
tables
to
define
like
the
different
command
elements
stuff.
So
this
is
relatively
friendly
and
then
his
build
script
just
takes
those
where's
his
build
script
there.
It
is
it.
It
reads
in
all
those
different
source
files
and
it
starts
to
generate
the
json
for
it.
B
So
it
has
partials
and
then
it
does
different
things
and
then
it
fills
everything
out
based
on
the
hash
tables
that
he's
provided
and
then
at
the
end
of
that
he
converts
all
of
that
to
json,
which
gives
you
your
manifest
for
crescendo
what
crescendo
needs
and
then
he
calls
export
crescendo
module.
It's
actually
really
freaking
clever,
because
adam
driscoll
was
really
freaking,
clever
like
that,
and
then
here's
his
update
module
manifest.
B
B
Maybe
it's
been
a
minute
since
I've
been
in
here,
but
this
is
where
you
could
do
the
work
of
having
a
build
step
that
runs
git
version
and
pulls
the
tags
in
the
commit
history
and
asserts
the
version
and
store
that
to
like
an
environment,
variable
on
your
on
your
ci
run
and
then
inside
of
here
instead
of
version.
If
you're,
using
like
azure,
devops
or
github
actions,
it
would
be
an
environment
variable
that
you
could
just
access
and
and
pass
to
this.
B
B
And
then,
let's
go
back
here
and
let's
see
if
this
actually
runs
because
some
of
this
I've
ran
before
some
of
it
is
brand
new
and
I
actually
don't
have
all
the
stuff
that
I
need
to
run
most
of
this,
like
I
don't
have
pens
and
all
that
good
stuff
to
do
this.
I
do
have
the
stuff
to
do
this,
though,
so,
if
I
were
to
say,
convert
to
pfx
certificate
and
remember
what
all
I
said.
Actually
you
know
what
here's,
what
we
can
do.
B
B
C
B
B
B
B
C
B
B
B
B
A
C
B
B
A
B
We'll
just
chalk
it
up
to
demo
gods
and
move
on
to
the
next
thing,
and
we
can
come
back
to
it
later.
If
I
really
care
to
dive
in
and
figure
out,
what's
going
on,
which
it
would
be
nice
to
figure
out
what's
going
on
there,
but
not
now,
let's
move
on
to
bigger
and
better,
although
this
is
going
to
be
largely
the
same,
but
I
wanted
to
show
you
one
of
the
cool
parts
of
crescendo
like
what
we
just
did
didn't
have
any
output
right.
B
It
just
generated
a
pfx
file
and
you
got
your
px
file
and
you
moved
on
with
your
day.
It's
fine,
but
there
are
times
where
the
native
command.
You
run.
You
expect
output
and
then
to
do
something
with
that
output
and
that's
where
crescendo
really
really
really
shines
is
in
these
output
handlers.
Now,
there's
a
couple
different
ways
that
you
can
do:
output
handlers.
B
B
Somewhere
on
here
is
a
link
out
to
a
bunch
of
blog
posts
written
by
mr
sean,
who
is
in
the
chat
and
on
the
call
here,
and
he
goes
through
output
handler
stuff.
So
how
do
you
define
one?
How
do
you
write
one?
What
does
that?
Look
like
so
almost
largely
the
same
thing
as
what
he's
doing
in
his
blog
post,
I've
written
a
couple
parsers
for
things
that
I
do
in
vagrant
as
well,
so
for
the
get
vagrant
status
commandlet.
B
B
Powershell
knows
about
this
function,
it's
called
parse
vagrant
status,
and
I
want
you
to
use
that
to
parse
the
output
of
this
native
command
and
give
me
a
powershell
object
back.
So
in
my
example
earlier,
what
I
did
was.
I
ran
vagrant
global
status
on
the
command
line,
and
I
got
this
output
back
well.
If
I
were
to
come
in
here,
ce
into
vagrant
and
import
vagrant.psd1.
B
It
did
yeah
because
I
told
it
to
if
we
look
at
if
we
look
at
par
vagrant
status.
So
if
we
look
at
vegan
global
status
again,
I
know
that
in
my
output
this
first
line
contains
my
columns
and
that
there's
nothing
that
I
want
from
this
line
and
all
of
my
data
lives
here
and
then
all
the
rest
of
this
stuff
is
just
junk.
So
I
don't
need
it
so
in
my
parse
vagrant
status
file,
I
say
hey
give
me
all
the
give
me
the
output.
So
lines
is
basically
an
array
of
the
output.
B
Split
here
ignore
all
the
spaces:
that's
a
column.
This
is
data.
This
is
data.
This
is
data.
This
is
data
technically,
this
is
still
going
to
match,
so
this
gets
captured
and
then
this
is
data,
data
data,
data
data,
etc,
etc.
And
then
we
build
our
object
out
of
all
of
those
different
chunks,
and
I
think
I
have
actually
one
no.
I
have
them
all
in
there
yeah
and
then
this
just
says
hey
where
the
id
is
not
equal
to
this,
and
it's
not
equal
to
this
return,
everything
else.
B
B
But
eventually
you
get
it
working
and
to
judd's
point
in
the
chat.
Regex
really
isn't
that
scary
once
you've
done
it
quite
a
bit,
but
depending
on
what
you're
doing
I
have
this
really
bad
habit
of
doing
named
captures
so
that
I
can
do
things
with
matches
a
little
bit
easier
because
that
just
in
my
brain
it
helps
me
a
lot.
So
I
will
match
on,
like
I'll,
have
a
named
match
for
id
a
named
match
for
name
provider,
state
directory,
etc.
B
So
it's
my
own
fault
that
my
regex
is
14
miles
long,
because
I
name
absolutely
everything
when
I
don't
have
to,
but
it
does
help
to
be
a
little
bit
clearer
when
you're
doing
things
it's
kind
of
self-documenting,
at
least
to
me
when
I'm
doing
regex.
The
name
stuff
really
helps
me,
but
that's
all
there
is
to
it
now.
You
could
do
that
inline.
B
It
doesn't
have
to
be
a
function
like
I've
defined
it
here
in
in
this
json
file.
It
absolutely
doesn't
have
to
be
a
function
because
if
it's
a
function,
powershell
needs
to
be
aware
of
this,
so
it
will
have
to
be
able
to
say
parse
vagrant
status,
for
example,
and
and
find
it
so
I
dot
source
these
files.
First,
you
could
pass
it.
I
believe
you
can
just
pass
it.
The
script
directly
from.
C
B
C
C
If,
if
the
type
is
set
to
script,
then
it
just
calls
the
script,
which
means
you
have
to
ship
the
script
with
your
module,
but
the
the
benefit
from
the
developer
side
of
that
is.
You
can
change
your
the
code
in
the
external
scripts
without
having
to
re-export
your
module,
because
it's
just
calling
that
external
script
file,
so
you
can
test
it
that
way
and
then
inline
has
to
go
in
the
json
and
who
wants
to
write
powershell
code
inside
of
the
json
string.
B
B
B
B
B
B
B
B
B
A
C
A
A
C
B
B
A
Repeatable,
because
if
it's,
if
it's
returning
data
every
time
in
different
formats
and
different
layouts,
that's
the
point
where
you
want
to
do
the
gripping
afterwards,
because
every
time
it's
unique,
if,
if
it's
the
same
every
time,
well,
why
not
just
roll
that
regex
search
in
to
the
command
line?
And
let
it
do
it
for
you
that
that's,
I
think
the
key
point
there.
B
B
If
the
output
is
from
an
error
and
it
fails,
you
regex,
like
that's
kind
of
the
point,
because
once
you
have
that
regex,
you
create
a
ps
custom
object
out
of
it.
You
now
can
do
all
that
other
fun
stuff
with
it.
You
can
pipe
it
to
whatever
you
want.
You
can
send
it
down
the
pipeline
to
another
command
that
does
further
processing.
You
can
filter
on
it.
You
can
convert
it
to
other
formats.
You
could
email
it.
You
could
convert
it
to
an
html
web
page.
You
could
invoke
rest
method.
B
B
A
A
B
B
C
C
That
creates
a
new
crescendo
command
and
then
keep
going.
Here's
your
new
configuration
and
scroll
back
up
that
new
configuration
so
yeah.
So
this
is
how
so
we've
created
that
command
in
the
previous
step
and
we're
assigning
that
command
to
the
dot
commands
array
of
the
new
configuration
object
and
and
then
you
can
convert
that
to
json
so
that
that
builds
out
the
json
framework.
And
then
you
can
start
editing
the
json.
B
C
A
All
right,
so
why
don't
we
wrap
up
here?
There's
some
very
happy
people
in
the
chat
here.
There's
some
people
that
came
into
this
meeting
looking
for
some
answers
for
things
they
were
trying
to
do
on
their
own
and
I
think
stevie
and
sean
have
basically
filled
in
the
gaps.
So
one
thing
I
want
to
point
out
here
that
is
assumed
that
may
not
be
apparent
is
first
of
all,
I
feel
like
the
crescendo.
Module
is
just
another
example
of
the
code
that
the
powershell
team
has
been
releasing.
A
Probably
what
I
can
remember
the
last
two
years,
even
in
the
preview
early
release
versions,
it's
very
solid
code:
you
can
do
a
lot
with
it
very
early
on.
Do
I
expect
the
crescendo
module
to
have
multiple
iterations
to
come
out
with
more
feature
sets
to
come
into
it
sure
for
right
now,
even
at
this
very
early
stage,
this
is
a
functional
tool-
that's
very
well
built
by
the
team,
and
it's
well
very
well
thought
out,
adding
on
to
that.
A
We
have
been
lucky
over
the
last
few
months
to
have
sean
wheeler
and
members
of
his
team
attend
our
user
group.
Sean
for
those
that
are
not
aware
is
responsible
for
the
documentation
or
one
of
the
members.
That's
responsible
for
the
documentation
for
the
powershell
core
language
and
sean
has
been
putting
in
an
inordinate
amount
of
time
over
the
past
year
and
a
half
trying
to
write
very
detailed
documentation,
but
also
build
up
the
other
areas
involved
with
powershell
and
the
stuff
that
they're
releasing
to
give
people
a
really
good
idea
about
what's
happening.
A
So
I
think
that
combination
of
great
modules
coming
out
excellent
documentation
to
support
it,
makes
it
easy
for
people
like
stevie
to
jump
in
and
figure
out
how
to
do
this
stuff.
So
this
gentleman,
like
adam
in
the
chat
here
adam
needed
a
few
holes
filled
in,
but
essentially
you
can
get
yourself
started
from
the
docs
and
the
code
that
exists
today.
There's
sean's
examples,
his
blog
posts
and
the
module.
That's
out
there.
It's
if
you
start
simple,
maybe
open
ssl
is
probably
not
the
first
command
that
you
want
your
command
line
tool.
A
A
Would-
and
I
don't
know
that
I
would
go
for
ipconfig
if
the
powershell
team
is
essentially
written
command
to
ready
to
replicate
a
lot
of
what
ipconfig
does,
but
with
yeah
well,
like
stevie,
pointed
out
vagrant.
That's
a
really
good
example
right,
it's
a
tool
that
you
might
be
using,
maybe
dc
diag
or
some
other
tools
that
you're
using
for
outside
of
the
powershell
world
right,
and
you
want
to
bring
that
in
so
baby.
Steps.
Get
you
to
the
finish
line.
C
C
A
C
A
April
may
so
three
four
months,
and
there
was
some
preview
releases,
but
so
you
you
just
need
to
understand
that
this
is
a
module
that
people
are
just
starting
to
get
get
their
feet
around.
People
like
stevie
and
adam
driscoll
are
sort
of
setting
a
trail
for
others
to
follow
and,
as
you
come
along,
you'll
fill
in
the
pieces,
so
you
can
build
your
own
stuff.
So,
being
we
like
to
encourage
you
to
go
out,
try
this
module
find
some
command
line
tools
that
you
could
use.
A
A
A
A
So,
thank
you
so
much
for
the
time
if
you're
following
us,
along
at
home
and
you'd
like
to
join
us
in
person,
the
research
triangle
power
show
user
group
meets
on
the
first
and
third
wednesday
of
the
month
and
we'd
love
to
have
you
in
person.
So
you
can
ask
your
own
questions.
You
can
find
us
on
meetup.com.
A
You
can
search
for
research
triangle,
powershell
user
group
or
you
can
go
to
rtpsub.com.
We
have
if
you're,
watching
this
on
youtube.
We
do
have
our
own
channel
with
about
110
videos
over
the
from
the
last
three
years
of
meetings.
So
there's
going
to
be
pretty
much
something
there
for
any
powershell
topic.
You
can
think
of
we'd
love
for
you
to
peruse
the
library
after
you
watch
your
videos
come
back
and
join
us
in
person.