Overview

The documentation pages in this section describe the RESTful APIs included with Cascade Profiler and Cascade Express products. It is assumed that the reader has practical knowledge of RESTful APIs, so the documentation does not go into detail about what REST is and how to use it. Instead the documentation focuses on what data can be accessed and how to access it.

The primary focus of the current version of the API is on providing access to reporting data. The following information can be accessed via the API:

• Reporting data (traffic data, service data, event list data, and user data)
• Information about network devices
• Control over SDN virtual network settings (SDN virtual network settings are a licensed feature)
• Information about system users

Details about REST resources can be found in the Resources section. This overview continues with how to run reports and retrieve data from them.

Running a report

The steps for running a report are described below. An easy way to learn how to run reports and get data is to use the Demo Reports section of this documentation. In that section a number of example reports are listed. If you click on any of the examples, the report will run along with a listing on the right side of the screen for each step in the process. It displays the REST resource, HTTP method, headers and body for both the request and response.

Follow these steps to run a report:

1. Create a new report by posting report criteria to the server.

A criteria structure in either JSON or XML is submitted to the server using the HTTP POST method. The resource to which the criteria structure is posted is called /profiler/1.0/reporting/reports. The details are described in the Resources section of this documentation.

A key part of the report criteria is the ID of the template that should be used to run the report. A special system template ID 184 that provides a high degree of flexibility is used in demo reports in this documentation. Additionally, any template that is saved via the user interface of the product can be used to run a report. In order to save a template, the ID of that template must be passed in the report criteria structure instead of 184. A template can be configured via the user interface, saved via the product and then used in the REST API to generate reports and retrieve them in a rendered form or in raw data form. Once a template is saved, its ID can be obtained via the /api/profiler/1.0/reporting/templates REST resource.

2. Poll report status until the report completes.

It may take a while for a report to complete. While the report is running, the client must poll for report status to know when the report completes. When the call to create a new report succeeds, it returns the URL for the newly created report. That URL may look similar to /profiler/1.0/reporting/reports/1000, which is the ID of the new report.

The general way to describe this in REST documentation is /profiler/1.0/reporting/reports/{id} so this documentation uses that syntax throughout. Note that the client does not need to know that {id} is really an ID of a report. Instead the client should treat a given report, for example /profiler/1.0/reporting/reports/1000, as a REST resource without parsing the parts of the URL.

The status of a report can be obtained by executing a GET method on the report URL. The client should wait while the report is running and until the status turns to state.

3. Retrieve the report data.

Once the report completes, the client can retrieve its data or the rendered version of the report in a number of formats.

The following resources can be used to retrieve a rendered version of the report:

• /profiler/1.0/reporting/reports/{id}/view.pdf
• /profiler/1.0/reporting/reports/{id}/view.csv

These are for PDF and CSV versions respectively.

If the client is a script that needs access to raw data, the /profiler/1.0/reporting/reports/{id}/queries resource can be used with the GET method to obtain the list of elements (queries) first. The data shown in a typical report on the user interface may come from more than one query, which is why the report structure needs to be determined first. However, the system template 184 described above will have only one query and is easy to use for simple scripts.

Each query resource provides metadata about the query, such as the list of columns with descriptions of what the columns are.

Once the query is chosen, the /profiler/1.0/reporting/reports/{id}/queries/{id} resource can be used to get the report data.

The simple overview provided above cannot substitute for full documentation and it is not intended to do so. Please refer to Demo Reports section to see how reports are run. Look at the Coding Examples under General Information and explore Resources section of this documentation for more information.

Authentication

All REST requests must be authenticated. The Authentication section of the Common 1.0 API describes which authentication methods are presently supported. There are also examples that show how to use each of the different authentication methods.

/api/profiler/1.0 to /api/profiler/1.1 Changelog

Changes to PUT method of /api/profiler/1.0/vnis resource

In version 1.0 this resource is used to update the name and description of virtual network identifiers passed in the input structure. The change in 1.1 is to allow passing non-existing virtual network identifiers. The API creates the unknown virtual network identifiers.

Added /api/profiler/1.1/system resource with the following subresources:

• POST /api/profiler/1.1/system/reboot
• POST /api/profiler/1.1/system/shutdown
• POST /api/profiler/1.1/system/start
• POST /api/profiler/1.1/system/stop
• POST /api/profiler/1.1/system/restart
• GET /api/profiler/1.1/system/status
• POST /api/profiler/1.1/system/kill

For more information please read the Resources documentation.

Added /api/profiler/1.1/system/{module} resource with the following subresources:

• POST /api/profiler/1.1/system/{module}/start
• POST /api/profiler/1.1/system/{module}/stop
• POST /api/profiler/1.1/system/{module}/restart
• GET /api/profiler/1.1/system/{module}/status
• POST /api/profiler/1.1/system/{module}/kill

For more information please read the Resources documentation.

Running a report: Sample PHP script

Run a report to get bytes and packets for the top 20 hosts using the application WEB. Use BASIC Authentication.

<?php

define('HOST', '127.0.0.1'); // IP address of Profiler
define('BASIC_AUTH', 'admin:admin');

// Timeframe
$end   = time() - 3*60; 
$start = $end   - 5*60;

// Lib functions

// HTTP POST
function do_POST($url, $string, &$info) {
  $curl = curl_init();
  curl_setopt($curl, CURLOPT_URL, $url);
  curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC ) ;
  curl_setopt($curl, CURLOPT_USERPWD, BASIC_AUTH);
  curl_setopt($curl, CURLOPT_SSLVERSION,3);
  curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, FALSE);
  curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, 2);
  curl_setopt($curl, CURLOPT_HEADER, true);
  curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($curl, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));
  curl_setopt($curl, CURLOPT_POST,           1);
  curl_setopt($curl, CURLOPT_POSTFIELDS,     $string);
  $output = curl_exec($curl);
  $info   = curl_getinfo($curl);
  curl_close($curl);

  $headers = substr($output, 0, $info['header_size']);
  $headers = explode("\n", $headers);
  $info['headers'] = $headers;
  $body = substr($output, $info['header_size']);
  return $body;
}

// HTTP GET
function do_GET($url, &$info) {
  $curl = curl_init();
  curl_setopt($curl, CURLOPT_URL, $url);
  curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC ) ;
  curl_setopt($curl, CURLOPT_USERPWD, BASIC_AUTH);
  curl_setopt($curl, CURLOPT_SSLVERSION,3);
  curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, FALSE);
  curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, 2);
  curl_setopt($curl, CURLOPT_HEADER, true);
  curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($curl, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));
  curl_setopt($curl, CURLOPT_HTTPGET, true);
  $output = curl_exec($curl);
  $info   = curl_getinfo($curl);
  curl_close($curl);

  $headers = substr($output, 0, $info['header_size']);
  $headers = explode("\n", $headers);
  $info['headers'] = $headers;
  $body = substr($output, $info['header_size']);
  return $body;
}

// Finds and returns HTTP header
function get_header($headers, $header) {
  foreach($headers as $h) {
    if (strpos($h, $header . ':') !== false)
      return trim(substr($h, 10));
  }
  echo "Unable to find {$header} header!\n";
  exit;
}

// Locates a column by id and returns the name
function find_column_name_by_id($columns, $id) {
  foreach ($columns as $c) {
    if ($c['id'] == $id)
      return $c['name'];
  }
  return 'Unknown';
}

// CSV helper
function echo_csv($headers, $rows) {
  echo implode(',', $headers) . "\n";
  foreach ($rows as $row)
    echo implode(',', $row) . "\n";
}

// End lib functions

$struct = 
  array('template_id' => 184,
        'criteria'    => Array('time_frame' => array('start' => $start,
                                                     'end'   => $end),
                               'traffic_expression' => 'app WEB',
                               'query' => array('realm'       => 'traffic_summary',
                                                'group_by'    => 'hos',
                                                'sort_column' => 33,
                                                'columns'     => array(6, 33, 34))));

$json    = json_encode($struct);
$columns = $struct['criteria']['query']['columns'];

// Post to run the report
$url = 'https://' . HOST . '/api/profiler/1.0/reporting/reports.json';
echo "Run report:\nPOST {$url}\n{$json}\n\n";
$info = array();
do_POST($url, $json, $info);
if ($info['http_code'] != 201) {
  echo "Unable to run report!\n";
  exit(1);
}
$location = get_header($info['headers'], 'Location');
echo "Generated: {$location}\n\n";
$status_url = 'https://' . HOST . '' . $location . '.json';

// Wait for it to complete
echo "Please wait\n";
while (true) {
  $info = array();
  $output = do_GET($status_url, $info);
  $s = json_decode($output, 1);
  print " Percent completed {$s['percent']}, seconds remaining {$s['remaining_seconds']}...\n";
  if ($s['status'] == 'completed') {
    echo "Completed\n\n";
    break;
  }
  sleep(1);
}

// Get all quesries (In this exampe it is only one)
$queries_url = 'https://' . HOST . '' . $location . '/queries.json';
$output = do_GET($queries_url, $info);
$queries = json_decode($output, 1);

// Print the data from all queries
foreach ($queries as $q) {
  $query_id = $q['id'];
  $data_url = 'https://' . HOST . '' . $location . '/queries/' . $query_id . '.json?offset=0&limit=20&columns=' . join(',', $columns);
  $info = array();
  $output = do_GET($data_url, $info);
  $data = json_decode($output, 1);

  $h = array();
  foreach ($columns as $c)
    $h[] = find_column_name_by_id($q['columns'], $c);

  echo_csv($h, $data['data']);
  echo "\n";
}

?>

Running a report: Sample Python script

Run a report to get bytes and packets for the top 20 hosts using the application WEB. Use BASIC Authentication.

from urlparse import urlparse
import base64
import logging
import httplib
import json
import time
import sys

HOST       = '127.0.0.1'
BASIC_AUTH = 'admin:admin'

end   = int(time.time() - 3*60)
start = int(end - 5*60);

# Lib functions

def do_POST(url, string):
    '''HTTP POST'''

    conn = httplib.HTTPSConnection(HOST, 443)

    headers = {"Authorization"  : "Basic %s" % base64.b64encode(BASIC_AUTH),
               "Content-Length" : str(len(string)),
               "Content-Type"   : "application/json"}

    conn.request('POST', url, body=string, headers=headers)

    res = conn.getresponse()

    info = {"status"  : res.status,
            "headers" : res.getheaders()}

    data = res.read()
    conn.close()
    return data, info

def do_GET(url):
    '''HTTP GET'''

    conn = httplib.HTTPSConnection(HOST, 443)

    headers = {"Authorization"  : "Basic %s" % base64.b64encode(BASIC_AUTH),
               "Content-Length" : 0,
               "Content-Type"   : "application/json"}

    conn.request('GET', url, body="", headers=headers)

    res = conn.getresponse()

    info = {"status"  : res.status,
            "headers" : res.getheaders()}

    data = res.read()
    conn.close()
    return data, info

def get_header(headers, header):
  '''Finds and returns HTTP header'''
  for i in headers:
    if (i[0] == header):
      return i[1]
  return ""

def find_column_name_by_id(columns, cid):
  '''Locates a column by id and returns the name'''
  for c in columns:
    if (c['id'] == cid):
      return c['name']
  return 'Unknown'

def echo_csv(headers, rows):
  '''CSV helper'''
  print ','.join(headers)
  for row in rows:
    print ','.join(row)

# End lib functions

struct = {
    "template_id" : 184,
    "criteria" : {
        "time_frame" : {
            "start" : start,
            "end"   : end
            },
        "traffic_expression" : "app WEB",
        "query" : {
            "realm"      : "traffic_summary",
            "group_by"   : "hos",
            "sort_column": 33,
            "columns"    : [6, 33, 34]
            }
        }
    }

to_post = json.dumps(struct)
columns = struct["criteria"]["query"]["columns"]

# Post to run the report
url = "https://%s/api/profiler/1.0/reporting/reports.json" % HOST
print "Run report:"
print "POST %s" % url
print "%s" % to_post

output, info = do_POST(url, to_post)
if (info['status'] is not 201):
  print "Unable to run report"
  sys.exit(1)

location = get_header(info['headers'], 'location')
print ""
print "Generated: %s" % location
print ""

status_url = "https://%s%s.json" % (HOST, location)

# Wait for it to complete
print "Please wait"
while (True):
  output, info = do_GET(status_url)
  s = json.loads(output)
  print "Percent completed %s, seconds remaining %s..." % (s["percent"], s["remaining_seconds"])
  if (s["status"] == "completed"):
    print "Completed"
    break
  time.sleep(1)

# Get all quesries (In this exampe it is only one)
queries_url = "https://%s%s/queries.json" % (HOST, location)

output, info = do_GET(queries_url)
queries = json.loads(output)

# Print the data from all queries
for q in queries:
  query_id = q['id'];
  columns_str = ','.join([repr(i) for i in columns])
  data_url = "https://%s%s/queries/%s.json?offset=0&limit=20&columns=%s" % (HOST, location, query_id, columns_str)
  output, info = do_GET(data_url)
  data = json.loads(output)

  h = []
  for c in columns:
    h.append(find_column_name_by_id(q["columns"], c))

  print ""  
  echo_csv(h, data["data"])

Running a report: Sample Perl script

Run a report to get bytes and packets for the top 20 hosts using the application WEB. Use BASIC Authentication.

#!/usr/bin/perl
use strict;
use warnings;

use LWP::UserAgent;
use HTTP::Request;
use List::MoreUtils qw(firstidx);
use JSON qw( encode_json decode_json );

use constant HOST     => '127.0.0.1';
use constant LOGIN    => 'admin';
use constant PASSWORD => 'admin';

our $ua = LWP::UserAgent->new;
$ua->agent("ProfilerScript/0.1");

our $API_BASE = "https://127.0.0.1";

sub _request($) 
{
  my $req = shift;

  $req->header('Accept' => 'application/json');
  $req->authorization_basic(LOGIN, PASSWORD);

  my $res = $ua->request($req);

  return {
    code    => $res->code,
    status  => $res->status_line,
    headers => $res->headers(),
    data    => decode_json($res->content)
  };
}

sub GET($) 
{
  my $req = HTTP::Request->new(GET => $API_BASE . shift);
  return _request($req);
}

sub POST($$) 
{
  my $req = HTTP::Request->new(POST => $API_BASE . shift);
  $req->content_type('application/json');
  $req->content(encode_json(shift));

  return _request($req);
}

my $end   = time();
my $start = $end - 5 * 60;

my $struct = { 
  template_id => 184, 
  criteria    => { 
    time_frame => { 
      start => $start, 
      end   => $end 
    }, 
    traffic_expression => "app WEB", 
    query => { 
      realm        => "traffic_summary", 
      group_by     => "hos", 
      sort_column  => 33, 
      columns      => [6, 33, 34] 
    } 
  } 
};

print "Running report... ";

my $response = POST('/api/profiler/1.0/reporting/reports', $struct);
die "Unable to run report. $response->{data}->{error_text}" unless $response->{code} == 201;

my $loc = $response->{headers}->header('Location');

while (1) 
{
  $response = GET($loc);
  printf "\rRunning report, %3d%% done, %d seconds remaining...   ", 
    $response->{data}->{percent}, 
    $response->{data}->{remaining_seconds};

  last if $response->{data}->{status} eq 'completed';
  sleep(1);
};

print "\nLoading data...\n";

$response = GET($loc . '/queries');
die "Unable to load queries. $response->{data}->{error_text}" unless $response->{code} == 200;

foreach my $query (@{$response->{data}})
{
  my @columns = @{$struct->{criteria}->{query}->{columns}};
  my $columns = join ',', @columns;

  my $data_response = GET("$loc/queries/$query->{id}?offset=0&limit=20&columns=$columns");
  die "Unable to load data. $response->{data}->{error_text}" unless $response->{code} == 200;

  my @indices = map { my $id = $_; firstidx { $_->{id} == $id } @{$query->{columns}} } @columns;

  print join ",", map { qq~"$query->{columns}->[$_]->{name}"~; } @indices;
  print "\n";

  foreach my $row (@{$data_response->{data}->{data}}) {
    print join ",", @$row;
    print "\n";
  }
}

Running a report: Sample .Net/C# code

Run a report to get bytes and packets for the top 20 hosts using the application WEB. Use BASIC Authentication.

Program.cs:

using System;
using System.Collections.Generic;
using System.Net;
using System.Runtime.Serialization.Json;
using System.Text;
using System.IO;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using System.Linq;
using System.Threading;
using System.Web.Script.Serialization;

namespace CascadeRestClient
{
    public class ReportUpdate
    {
        public string status { get; set; }
        public string user_id { get; set; }
        public string name { get; set; }
        public string percent { get; set; }
        public string id { get; set; }
        public string remaining_seconds { get; set; }
        public string run_time { get; set; }
        public string saved { get; set; }
        public string template_id { get; set; }
        public string size { get; set; }
    }

    public class Column
    {
        public string strid { get; set; }
        public string metric { get; set; }
        public string rate { get; set; }
        public string statistic { get; set; }
        public int id { get; set; }
        public string unit { get; set; }
        public string category { get; set; }
        public string severity { get; set; }
        public string area { get; set; }
        public bool @internal { get; set; }
        public string role { get; set; }
        public string cli_srv { get; set; }
        public string type { get; set; }
        public bool available { get; set; }
        public string direction { get; set; }
        public string comparison { get; set; }
        public bool sortable { get; set; }
        public string name { get; set; }
        public string comparison_parameter { get; set; }
        public bool has_others { get; set; }
        public bool context { get; set; }
        public string name_type { get; set; }
    }

    public class QueryResult
    {
        public string direction { get; set; }
        public string actual_log { get; set; }
        public int actual_t0 { get; set; }
        public bool sort_desc { get; set; }
        public string area { get; set; }
        public string metric { get; set; }
        public int sort_col { get; set; }
        public string parent_id { get; set; }
        public string rate { get; set; }
        public string group_by { get; set; }
        public string role { get; set; }
        public List<Column> columns { get; set; }
        public string statistic { get; set; }
        public string type { get; set; }
        public string id { get; set; }
        public string unit { get; set; }
        public int actual_t1 { get; set; }
    }

    public class QueryData
    {
        public List<List<string>> data { get; set; }
        public int data_size { get; set; }
        public List<string> totals { get; set; }
    }

    class Program
    {
        static string BASIC_AUTH = "admin:admin";

        // callback used to validate the self-gen certificate in an SSL conversation
        private static bool ValidateRemoteCertificate(object sender, X509Certificate cert, X509Chain chain, SslPolicyErrors policyErrors)
        {
            return true;
            /*
            X509Certificate2 certv2 = new X509Certificate2(cert);
            if (certv2.GetNameInfo(X509NameType.SimpleName,true) == "www.riverbed.com")
                return true;

            return false;
             */
        }

        static void Main(string[] args)
        {
            if (args.Length == 0 || string.IsNullOrWhiteSpace(args[0]))
            {
                Console.WriteLine("Usage: CascadeRestClient hostname");
                return;
            }
            try
            {
                //Code to allow run with self-signed certificates
                // validate cert by calling a function
                ServicePointManager.ServerCertificateValidationCallback += new RemoteCertificateValidationCallback(ValidateRemoteCertificate);

                //Starting to run rest 
                string rootUrl = "https://" + args[0];
                string requestUrl = rootUrl + "/api/profiler/1.0/reporting/reports.json";
                string location;

                int start = (int)((DateTime.Now - new DateTime(1970, 1, 1).ToLocalTime()).TotalSeconds) - 8*60; //8 minutes before in unix time
                int end = start + 5*60; //3 minutes before in unix time

                var jsondata = new
                {
                    template_id = 184,
                    criteria = new
                    {
                        time_frame = new
                        {
                            start = start,
                            end = end
                        },

                        traffic_expression = "app WEB",
                        query = new
                        {
                            realm = "traffic_summary",
                            group_by = "hos",
                            sort_column = 33,
                            columns = new List<int> { 6, 33, 34 }
                        }
                    }
                };

                //Serialize anomymous type to json
                JavaScriptSerializer serializer = new JavaScriptSerializer();
                string postData = serializer.Serialize(jsondata);

                Console.WriteLine("Run report:");
                Console.WriteLine("POST " + requestUrl);
                Console.WriteLine(postData + Environment.NewLine);

                // Post to run the report
                var runReportResponse = MakeRequest<ReportUpdate>(requestUrl, WebRequestMethods.Http.Post, out location, postData);
                Console.WriteLine("Generated " + location + Environment.NewLine);
                requestUrl = rootUrl + location;
                Console.WriteLine("Please wait");
                while (runReportResponse.status != "completed")
                {
                    runReportResponse = MakeRequest<ReportUpdate>(requestUrl + ".json", WebRequestMethods.Http.Get, out location);
                    Console.WriteLine(string.Format("Percent completed {0}, seconds remaining {1}",runReportResponse.percent, runReportResponse.remaining_seconds));
                    Thread.Sleep(1000);
                }
                Console.WriteLine("Completed"+ Environment.NewLine);

                // Get all quesries (In this example it is only one)
                var getQueriesResponse = MakeRequest<List<QueryResult>>(requestUrl +"/queries.json", WebRequestMethods.Http.Get, out location);
                string columns = jsondata.criteria.query.columns.Select(c=>c.ToString()).Aggregate((i, j) => i + "," + j);
                // Print the data from all queries
                foreach (var query in getQueriesResponse) {
                    var qr = MakeRequest<QueryData>(requestUrl + "/queries/" + query.id + ".json?offset=0&limit=20&columns=" + columns,
                                                   WebRequestMethods.Http.Get, out location);
                    string columnList = jsondata.criteria.query.columns.Select(c=>query.columns.Where(col => col.id == c).First().name)
                                                              .Aggregate((l,r) => l + "," + r);
                    Console.WriteLine(columnList);

                    foreach (var dr in qr.data)
                    {
                        Console.WriteLine(dr.Aggregate((i, j) => i + ',' + j));
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }


        private static string Base64Encode(string toEncode)
        {
            byte[] toEncodeAsBytes
            = System.Text.ASCIIEncoding.ASCII.GetBytes(toEncode);
            return System.Convert.ToBase64String(toEncodeAsBytes);
        }

        /// <summary>
        /// Make request
        /// </summary>
        /// <typeparam name="T">return type</typeparam>
        /// <param name="requestUrl">url for request</param>
        /// <param name="action">Http Verb, Get, Post etc</param>
        /// <param name="location">location returned from response header </param>
        /// <param name="requestData">Data posted</param>
        /// <returns></returns>
        private static T MakeRequest<T>(string requestUrl, string action, out string location, string requestData = null) where T : class
        {
            HttpWebRequest request = WebRequest.Create(requestUrl) as HttpWebRequest;
            request.Headers.Add("Authorization: Basic " + Base64Encode(BASIC_AUTH));
            request.ContentType = "application/json";
            request.Method = action;
            if (requestData == null)
            {
                request.ContentLength = 0;
            }
            else
            {
                ASCIIEncoding encoding = new ASCIIEncoding();
                byte[] byte1 = encoding.GetBytes(requestData);
                request.ContentLength = byte1.Length;
                using (Stream newStream = request.GetRequestStream())
                {
                    newStream.Write(byte1, 0, byte1.Length);
                }
            }

            using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
            {
                if (response.StatusCode != HttpStatusCode.OK && response.StatusCode != HttpStatusCode.Created)
                    throw new Exception(String.Format(
                    "Unable to run report! StatusCode={0}, Description={1}",
                    response.StatusCode,
                    response.StatusDescription));
                location = response.Headers[HttpResponseHeader.Location];
                DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(T));
                object objResponse = jsonSerializer.ReadObject(response.GetResponseStream());
                return objResponse as T;
            }
        }
    }
}

CascadeRestClient.csproj:

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <ProductVersion>8.0.30703</ProductVersion>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{4ED69347-523B-46AB-B259-47EF60D4F13A}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>CascadeRestClient</RootNamespace>
    <AssemblyName>CascadeRestClient</AssemblyName>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    <TargetFrameworkProfile>
    </TargetFrameworkProfile>
    <FileAlignment>512</FileAlignment>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Web.Extensions">
      <HintPath>..\..\..\..\..\..\..\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Web.Extensions.dll</HintPath>
    </Reference>
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Program.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>