hi everybody my name is Tim muting and
with C Technologies and today I've got
dan O'Brien here with me he's going to
give us a demonstration around release
automation dan what are we going to see
today sure so what we're going to do
today is are going to deploy a full
application using release automation and
we're going to leverage CA lisa service
virtualization so essentially what we're
going to do is rather than waiting for
the constraints of hardware and
environments to be built and ready for
us to do our testing whether you have
the ability to deploy virtual a service
so we can get all those same responses
back that we need to test to test our
code changes on so rapidly it sounds
very good let's uh let's see how it
works okay okay so in this case what we
want to do is we have a simple change to
a deployed application and we want to be
able to test that change it's just a in
this case it's small change to the front
end web UI but in order to test even as
simple as changes a QA personal tester
is going to need the entire environment
so they're going to need everything from
the database the application any
external components you know that
necessary to do the test but the problem
is they're not always available when we
need them so what we're going to do here
is we're going to actually do a release
of this application and we're going to
release it using a virtualized back end
so we're going to use CA Lisa service
virtualization to to create and deploy
the entire environment virtualized so
that we can test out the changes that
will just make it a front end web UI so
let's go ahead and go into the template
here and we'll create a new release just
give it a name here forward Inc vs for
virtual service we'll go ahead and give
it a version and we'll put it in the
environment for virtualized services
environment okay we'll go ahead and do
that and hit create and so what's going
to happen now is will run the will run
the initialization step so in this case
what we're doing is we're going out to
the source control repositories and
we're determining if there's you know if
we have the right files the right
versions are out there we can access
them and we're also determining what
what's serve and what virtualized
services we're going to use for this
deployment once that initialization
steps completes we'll go ahead and
actually deploy that virtual service
okay so you see here we read in the
initialization we read the manifest file
and we can see that for this deployment
it's simply just two items that we have
to deploy one is well go ahead and
deploy the full application web UI okay
then everything else behind now we're
going to virtualize using service
virtualization from CA okay so let's go
ahead and run that okay and then that
goes that's going to go ahead and run
and Wallace is happening you see here
within a we are using continuous
integration by Jenkins and we already
have a continuous integration job for
the for this ticket exchange for forward
Inc what will happen is we're going to
create a new one as a result of this new
deployment using virtualized services
will create a new continuous integration
job as well so that we can keep you know
keep the builds you know up to up to
date with you know when new items are
checked into the repository and you see
here now we've deployed the the ticket
exchange web UI we're actually going
ahead and deploying that virtualized web
service right now and then when that's
done we'll just go into the post deploy
and we'll just do a quick sanity test
using Lisa and of course we'll go ahead
and create that continuous integration
job okay so that's done and it will roll
over to post deployment and live run
those two items once the test is run
what we can do from a notification
perspective is so an email off to the
folks who need it to see if the tests
were successful so let's just fire up
the mail program i'll show you that and
you see here that every every every
minute or service so often we have a job
that runs and it just test to make sure
that we can hit the site we can hit all
the way through to the back end so we
can you know exercise a database the
external authentication which everything
works and we attach a full report of
that test that test case right there
okay
and then we can see here that where the
set the test case is complete the
continuous integration job is running if
I go over to Jenkins and I just reload
this page what we'll see here is that we
have now a new forwarding virtualized
service continuous integration job
that's been created by CA release
automation and there you have it so then
we saw release automation see a release
automation and we talked about how it
really helps to streamline and speed up
manage that whole application delivery
process itself the deployment process we
integrated that with see Lisa service
virtualization talk a little bit more
about the specifics around that yeah
sure and so the key benefits with
service virtualization is eliminate the
constraints that we normally see as
developers and as testers we know we
need environments we need them right
away right now for testing coach changes
and oftentimes we find out those
environments are not ready we just have
resource constraints maybe we don't have
the amount of environment I needed to
perform the amount of tests we want and
we need to make particularly in an agile
development you know methodology so
service virtualization remove those
constraints and allows us to perform our
testing you know right away when we're
ready to use fantastic very good more
demonstrations like this around see
elusive tariff service virtualization as
well as release automation visits ta com
you