Update azure dependency. Add contianer registry.

2026-01-04 23:17:50 +00:00 · 2016-12-06 22:14:21 -08:00
parent bb792b17e4
commit 8d90cadc0b
79 changed files with 5225 additions and 2031 deletions
--- a/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/environments.go
@@ -19,93 +19,103 @@ var environments = map[string]Environment{

 // Environment represents a set of endpoints for each of Azure's Clouds.
 type Environment struct {
-	Name                      string `json:"name"`
-	ManagementPortalURL       string `json:"managementPortalURL"`
-	PublishSettingsURL        string `json:"publishSettingsURL"`
-	ServiceManagementEndpoint string `json:"serviceManagementEndpoint"`
-	ResourceManagerEndpoint   string `json:"resourceManagerEndpoint"`
-	ActiveDirectoryEndpoint   string `json:"activeDirectoryEndpoint"`
-	GalleryEndpoint           string `json:"galleryEndpoint"`
-	KeyVaultEndpoint          string `json:"keyVaultEndpoint"`
-	GraphEndpoint             string `json:"graphEndpoint"`
-	StorageEndpointSuffix     string `json:"storageEndpointSuffix"`
-	SQLDatabaseDNSSuffix      string `json:"sqlDatabaseDNSSuffix"`
-	TrafficManagerDNSSuffix   string `json:"trafficManagerDNSSuffix"`
-	KeyVaultDNSSuffix         string `json:"keyVaultDNSSuffix"`
-	ServiceBusEndpointSuffix  string `json:"serviceBusEndpointSuffix"`
+	Name                         string `json:"name"`
+	ManagementPortalURL          string `json:"managementPortalURL"`
+	PublishSettingsURL           string `json:"publishSettingsURL"`
+	ServiceManagementEndpoint    string `json:"serviceManagementEndpoint"`
+	ResourceManagerEndpoint      string `json:"resourceManagerEndpoint"`
+	ActiveDirectoryEndpoint      string `json:"activeDirectoryEndpoint"`
+	GalleryEndpoint              string `json:"galleryEndpoint"`
+	KeyVaultEndpoint             string `json:"keyVaultEndpoint"`
+	GraphEndpoint                string `json:"graphEndpoint"`
+	StorageEndpointSuffix        string `json:"storageEndpointSuffix"`
+	SQLDatabaseDNSSuffix         string `json:"sqlDatabaseDNSSuffix"`
+	TrafficManagerDNSSuffix      string `json:"trafficManagerDNSSuffix"`
+	KeyVaultDNSSuffix            string `json:"keyVaultDNSSuffix"`
+	ServiceBusEndpointSuffix     string `json:"serviceBusEndpointSuffix"`
+	ServiceManagementVMDNSSuffix string `json:"serviceManagementVMDNSSuffix"`
+	ResourceManagerVMDNSSuffix   string `json:"resourceManagerVMDNSSuffix"`
 }

 var (
 	// PublicCloud is the default public Azure cloud environment
 	PublicCloud = Environment{
-		Name:                      "AzurePublicCloud",
-		ManagementPortalURL:       "https://manage.windowsazure.com/",
-		PublishSettingsURL:        "https://manage.windowsazure.com/publishsettings/index",
-		ServiceManagementEndpoint: "https://management.core.windows.net/",
-		ResourceManagerEndpoint:   "https://management.azure.com/",
-		ActiveDirectoryEndpoint:   "https://login.microsoftonline.com/",
-		GalleryEndpoint:           "https://gallery.azure.com/",
-		KeyVaultEndpoint:          "https://vault.azure.net/",
-		GraphEndpoint:             "https://graph.windows.net/",
-		StorageEndpointSuffix:     "core.windows.net",
-		SQLDatabaseDNSSuffix:      "database.windows.net",
-		TrafficManagerDNSSuffix:   "trafficmanager.net",
-		KeyVaultDNSSuffix:         "vault.azure.net",
-		ServiceBusEndpointSuffix:  "servicebus.azure.com",
+		Name:                         "AzurePublicCloud",
+		ManagementPortalURL:          "https://manage.windowsazure.com/",
+		PublishSettingsURL:           "https://manage.windowsazure.com/publishsettings/index",
+		ServiceManagementEndpoint:    "https://management.core.windows.net/",
+		ResourceManagerEndpoint:      "https://management.azure.com/",
+		ActiveDirectoryEndpoint:      "https://login.microsoftonline.com/",
+		GalleryEndpoint:              "https://gallery.azure.com/",
+		KeyVaultEndpoint:             "https://vault.azure.net/",
+		GraphEndpoint:                "https://graph.windows.net/",
+		StorageEndpointSuffix:        "core.windows.net",
+		SQLDatabaseDNSSuffix:         "database.windows.net",
+		TrafficManagerDNSSuffix:      "trafficmanager.net",
+		KeyVaultDNSSuffix:            "vault.azure.net",
+		ServiceBusEndpointSuffix:     "servicebus.azure.com",
+		ServiceManagementVMDNSSuffix: "cloudapp.net",
+		ResourceManagerVMDNSSuffix:   "cloudapp.azure.com",
 	}

 	// USGovernmentCloud is the cloud environment for the US Government
 	USGovernmentCloud = Environment{
-		Name:                      "AzureUSGovernmentCloud",
-		ManagementPortalURL:       "https://manage.windowsazure.us/",
-		PublishSettingsURL:        "https://manage.windowsazure.us/publishsettings/index",
-		ServiceManagementEndpoint: "https://management.core.usgovcloudapi.net/",
-		ResourceManagerEndpoint:   "https://management.usgovcloudapi.net/",
-		ActiveDirectoryEndpoint:   "https://login.microsoftonline.com/",
-		GalleryEndpoint:           "https://gallery.usgovcloudapi.net/",
-		KeyVaultEndpoint:          "https://vault.usgovcloudapi.net/",
-		GraphEndpoint:             "https://graph.usgovcloudapi.net/",
-		StorageEndpointSuffix:     "core.usgovcloudapi.net",
-		SQLDatabaseDNSSuffix:      "database.usgovcloudapi.net",
-		TrafficManagerDNSSuffix:   "usgovtrafficmanager.net",
-		KeyVaultDNSSuffix:         "vault.usgovcloudapi.net",
-		ServiceBusEndpointSuffix:  "servicebus.usgovcloudapi.net",
+		Name:                         "AzureUSGovernmentCloud",
+		ManagementPortalURL:          "https://manage.windowsazure.us/",
+		PublishSettingsURL:           "https://manage.windowsazure.us/publishsettings/index",
+		ServiceManagementEndpoint:    "https://management.core.usgovcloudapi.net/",
+		ResourceManagerEndpoint:      "https://management.usgovcloudapi.net/",
+		ActiveDirectoryEndpoint:      "https://login.microsoftonline.com/",
+		GalleryEndpoint:              "https://gallery.usgovcloudapi.net/",
+		KeyVaultEndpoint:             "https://vault.usgovcloudapi.net/",
+		GraphEndpoint:                "https://graph.usgovcloudapi.net/",
+		StorageEndpointSuffix:        "core.usgovcloudapi.net",
+		SQLDatabaseDNSSuffix:         "database.usgovcloudapi.net",
+		TrafficManagerDNSSuffix:      "usgovtrafficmanager.net",
+		KeyVaultDNSSuffix:            "vault.usgovcloudapi.net",
+		ServiceBusEndpointSuffix:     "servicebus.usgovcloudapi.net",
+		ServiceManagementVMDNSSuffix: "usgovcloudapp.net",
+		ResourceManagerVMDNSSuffix:   "cloudapp.windowsazure.us",
 	}

 	// ChinaCloud is the cloud environment operated in China
 	ChinaCloud = Environment{
-		Name:                      "AzureChinaCloud",
-		ManagementPortalURL:       "https://manage.chinacloudapi.com/",
-		PublishSettingsURL:        "https://manage.chinacloudapi.com/publishsettings/index",
-		ServiceManagementEndpoint: "https://management.core.chinacloudapi.cn/",
-		ResourceManagerEndpoint:   "https://management.chinacloudapi.cn/",
-		ActiveDirectoryEndpoint:   "https://login.chinacloudapi.cn/?api-version=1.0",
-		GalleryEndpoint:           "https://gallery.chinacloudapi.cn/",
-		KeyVaultEndpoint:          "https://vault.azure.cn/",
-		GraphEndpoint:             "https://graph.chinacloudapi.cn/",
-		StorageEndpointSuffix:     "core.chinacloudapi.cn",
-		SQLDatabaseDNSSuffix:      "database.chinacloudapi.cn",
-		TrafficManagerDNSSuffix:   "trafficmanager.cn",
-		KeyVaultDNSSuffix:         "vault.azure.cn",
-		ServiceBusEndpointSuffix:  "servicebus.chinacloudapi.net",
+		Name:                         "AzureChinaCloud",
+		ManagementPortalURL:          "https://manage.chinacloudapi.com/",
+		PublishSettingsURL:           "https://manage.chinacloudapi.com/publishsettings/index",
+		ServiceManagementEndpoint:    "https://management.core.chinacloudapi.cn/",
+		ResourceManagerEndpoint:      "https://management.chinacloudapi.cn/",
+		ActiveDirectoryEndpoint:      "https://login.chinacloudapi.cn/?api-version=1.0",
+		GalleryEndpoint:              "https://gallery.chinacloudapi.cn/",
+		KeyVaultEndpoint:             "https://vault.azure.cn/",
+		GraphEndpoint:                "https://graph.chinacloudapi.cn/",
+		StorageEndpointSuffix:        "core.chinacloudapi.cn",
+		SQLDatabaseDNSSuffix:         "database.chinacloudapi.cn",
+		TrafficManagerDNSSuffix:      "trafficmanager.cn",
+		KeyVaultDNSSuffix:            "vault.azure.cn",
+		ServiceBusEndpointSuffix:     "servicebus.chinacloudapi.net",
+		ServiceManagementVMDNSSuffix: "chinacloudapp.cn",
+		ResourceManagerVMDNSSuffix:   "cloudapp.azure.cn",
 	}

 	// GermanCloud is the cloud environment operated in Germany
 	GermanCloud = Environment{
-		Name:                      "AzureGermanCloud",
-		ManagementPortalURL:       "http://portal.microsoftazure.de/",
-		PublishSettingsURL:        "https://manage.microsoftazure.de/publishsettings/index",
-		ServiceManagementEndpoint: "https://management.core.cloudapi.de/",
-		ResourceManagerEndpoint:   "https://management.microsoftazure.de/",
-		ActiveDirectoryEndpoint:   "https://login.microsoftonline.de/",
-		GalleryEndpoint:           "https://gallery.cloudapi.de/",
-		KeyVaultEndpoint:          "https://vault.microsoftazure.de/",
-		GraphEndpoint:             "https://graph.cloudapi.de/",
-		StorageEndpointSuffix:     "core.cloudapi.de",
-		SQLDatabaseDNSSuffix:      "database.cloudapi.de",
-		TrafficManagerDNSSuffix:   "azuretrafficmanager.de",
-		KeyVaultDNSSuffix:         "vault.microsoftazure.de",
-		ServiceBusEndpointSuffix:  "servicebus.cloudapi.de",
+		Name:                         "AzureGermanCloud",
+		ManagementPortalURL:          "http://portal.microsoftazure.de/",
+		PublishSettingsURL:           "https://manage.microsoftazure.de/publishsettings/index",
+		ServiceManagementEndpoint:    "https://management.core.cloudapi.de/",
+		ResourceManagerEndpoint:      "https://management.microsoftazure.de/",
+		ActiveDirectoryEndpoint:      "https://login.microsoftonline.de/",
+		GalleryEndpoint:              "https://gallery.cloudapi.de/",
+		KeyVaultEndpoint:             "https://vault.microsoftazure.de/",
+		GraphEndpoint:                "https://graph.cloudapi.de/",
+		StorageEndpointSuffix:        "core.cloudapi.de",
+		SQLDatabaseDNSSuffix:         "database.cloudapi.de",
+		TrafficManagerDNSSuffix:      "azuretrafficmanager.de",
+		KeyVaultDNSSuffix:            "vault.microsoftazure.de",
+		ServiceBusEndpointSuffix:     "servicebus.cloudapi.de",
+		ServiceManagementVMDNSSuffix: "azurecloudapp.de",
+		ResourceManagerVMDNSSuffix:   "cloudapp.microsoftazure.de",
 	}
 )

@@ -121,8 +131,13 @@ func EnvironmentFromName(name string) (Environment, error) {

 // OAuthConfigForTenant returns an OAuthConfig with tenant specific urls
 func (env Environment) OAuthConfigForTenant(tenantID string) (*OAuthConfig, error) {
+	return OAuthConfigForTenant(env.ActiveDirectoryEndpoint, tenantID)
+}
+
+// OAuthConfigForTenant returns an OAuthConfig with tenant specific urls for target cloud auth endpoint
+func OAuthConfigForTenant(activeDirectoryEndpoint, tenantID string) (*OAuthConfig, error) {
 	template := "%s/oauth2/%s?api-version=%s"
-	u, err := url.Parse(env.ActiveDirectoryEndpoint)
+	u, err := url.Parse(activeDirectoryEndpoint)
 	if err != nil {
 		return nil, err
 	}
--- a/vendor/github.com/Azure/go-autorest/autorest/azure/token.go
+++ b/vendor/github.com/Azure/go-autorest/autorest/azure/token.go
@@ -91,7 +91,7 @@ type ServicePrincipalNoSecret struct {
 // SetAuthenticationValues is a method of the interface ServicePrincipalSecret
 // It only returns an error for the ServicePrincipalNoSecret type
 func (noSecret *ServicePrincipalNoSecret) SetAuthenticationValues(spt *ServicePrincipalToken, v *url.Values) error {
-	return fmt.Errorf("Manually created ServicePrincipalToken does not contain secret material to retrieve a new access token.")
+	return fmt.Errorf("Manually created ServicePrincipalToken does not contain secret material to retrieve a new access token")
 }

 // ServicePrincipalSecret is an interface that allows various secret mechanism to fill the form
@@ -138,7 +138,7 @@ func (secret *ServicePrincipalCertificateSecret) SignJwt(spt *ServicePrincipalTo
 	token := jwt.New(jwt.SigningMethodRS256)
 	token.Header["x5t"] = thumbprint
 	token.Claims = jwt.MapClaims{
-		"aud": spt.oauthConfig.TokenEndpoint,
+		"aud": spt.oauthConfig.TokenEndpoint.String(),
 		"iss": spt.clientID,
 		"sub": spt.clientID,
 		"jti": base64.URLEncoding.EncodeToString(jti),
--- a/vendor/github.com/Azure/go-autorest/autorest/client.go
+++ b/vendor/github.com/Azure/go-autorest/autorest/client.go
@@ -20,9 +20,6 @@ const (

 	// DefaultRetryAttempts is number of attempts for retry status codes (5xx).
 	DefaultRetryAttempts = 3
-
-	// DefaultRetryDuration is a resonable delay for retry.
-	defaultRetryInterval = 30 * time.Second
 )

 var statusCodesForRetry = []int{
@@ -130,6 +127,9 @@ type Client struct {
 	// RetryAttempts sets the default number of retry attempts for client.
 	RetryAttempts int

+	// RetryDuration sets the delay duration for retries.
+	RetryDuration time.Duration
+
 	// UserAgent, if not empty, will be set as the HTTP User-Agent header on all requests sent
 	// through the Do method.
 	UserAgent string
@@ -144,6 +144,7 @@ func NewClientWithUserAgent(ua string) Client {
 		PollingDelay:    DefaultPollingDelay,
 		PollingDuration: DefaultPollingDuration,
 		RetryAttempts:   DefaultRetryAttempts,
+		RetryDuration:   30 * time.Second,
 		UserAgent:       ua,
 	}
 }
@@ -163,7 +164,7 @@ func (c Client) Do(r *http.Request) (*http.Response, error) {
 		return nil, NewErrorWithError(err, "autorest/Client", "Do", nil, "Preparing request failed")
 	}
 	resp, err := SendWithSender(c.sender(), r,
-		DoRetryForStatusCodes(c.RetryAttempts, defaultRetryInterval, statusCodesForRetry...))
+		DoRetryForStatusCodes(c.RetryAttempts, c.RetryDuration, statusCodesForRetry...))
 	Respond(resp,
 		c.ByInspecting())
 	return resp, err
--- a/vendor/github.com/Azure/go-autorest/autorest/date/time.go
+++ b/vendor/github.com/Azure/go-autorest/autorest/date/time.go
@@ -1,12 +1,17 @@
 package date

 import (
+	"regexp"
 	"time"
 )

+// Azure reports time in UTC but it doesn't include the 'Z' time zone suffix in some cases.
 const (
-	rfc3339JSON = `"` + time.RFC3339Nano + `"`
-	rfc3339     = time.RFC3339Nano
+	azureUtcFormatJSON = `"2006-01-02T15:04:05.999999999"`
+	azureUtcFormat     = "2006-01-02T15:04:05.999999999"
+	rfc3339JSON        = `"` + time.RFC3339Nano + `"`
+	rfc3339            = time.RFC3339Nano
+	tzOffsetRegex      = `(Z|z|\+|-)(\d+:\d+)*"*$`
 )

 // Time defines a type similar to time.Time but assumes a layout of RFC3339 date-time (i.e.,
@@ -36,7 +41,14 @@ func (t Time) MarshalJSON() (json []byte, err error) {
 // UnmarshalJSON reconstitutes the Time from a JSON string conforming to RFC3339 date-time
 // (i.e., 2006-01-02T15:04:05Z).
 func (t *Time) UnmarshalJSON(data []byte) (err error) {
-	t.Time, err = ParseTime(rfc3339JSON, string(data))
+	timeFormat := azureUtcFormatJSON
+	match, err := regexp.Match(tzOffsetRegex, data)
+	if err != nil {
+		return err
+	} else if match {
+		timeFormat = rfc3339JSON
+	}
+	t.Time, err = ParseTime(timeFormat, string(data))
 	return err
 }

@@ -49,7 +61,14 @@ func (t Time) MarshalText() (text []byte, err error) {
 // UnmarshalText reconstitutes a Time saved as a byte array conforming to RFC3339 date-time
 // (i.e., 2006-01-02T15:04:05Z).
 func (t *Time) UnmarshalText(data []byte) (err error) {
-	t.Time, err = ParseTime(rfc3339, string(data))
+	timeFormat := azureUtcFormat
+	match, err := regexp.Match(tzOffsetRegex, data)
+	if err != nil {
+		return err
+	} else if match {
+		timeFormat = rfc3339
+	}
+	t.Time, err = ParseTime(timeFormat, string(data))
 	return err
 }

--- a/vendor/github.com/Azure/go-autorest/autorest/preparer.go
+++ b/vendor/github.com/Azure/go-autorest/autorest/preparer.go
@@ -4,7 +4,9 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"io"
 	"io/ioutil"
+	"mime/multipart"
 	"net/http"
 	"net/url"
 	"strings"
@@ -197,6 +199,64 @@ func WithFormData(v url.Values) PrepareDecorator {
 	}
 }

+// WithMultiPartFormData returns a PrepareDecoratore that "URL encodes" (e.g., bar=baz&foo=quux) form parameters
+// into the http.Request body.
+func WithMultiPartFormData(formDataParameters map[string]interface{}) PrepareDecorator {
+	return func(p Preparer) Preparer {
+		return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+			r, err := p.Prepare(r)
+			if err == nil {
+				var body bytes.Buffer
+				writer := multipart.NewWriter(&body)
+				for key, value := range formDataParameters {
+					if rc, ok := value.(io.ReadCloser); ok {
+						var fd io.Writer
+						if fd, err = writer.CreateFormFile(key, key); err != nil {
+							return r, err
+						}
+						if _, err = io.Copy(fd, rc); err != nil {
+							return r, err
+						}
+					} else {
+						if err = writer.WriteField(key, ensureValueString(value)); err != nil {
+							return r, err
+						}
+					}
+				}
+				if err = writer.Close(); err != nil {
+					return r, err
+				}
+				if r.Header == nil {
+					r.Header = make(http.Header)
+				}
+				r.Header.Set(http.CanonicalHeaderKey(headerContentType), writer.FormDataContentType())
+				r.Body = ioutil.NopCloser(bytes.NewReader(body.Bytes()))
+				r.ContentLength = int64(body.Len())
+				return r, err
+			}
+			return r, err
+		})
+	}
+}
+
+// WithFile returns a PrepareDecorator that sends file in request body.
+func WithFile(f io.ReadCloser) PrepareDecorator {
+	return func(p Preparer) Preparer {
+		return PreparerFunc(func(r *http.Request) (*http.Request, error) {
+			r, err := p.Prepare(r)
+			if err == nil {
+				b, err := ioutil.ReadAll(f)
+				if err != nil {
+					return r, err
+				}
+				r.Body = ioutil.NopCloser(bytes.NewReader(b))
+				r.ContentLength = int64(len(b))
+			}
+			return r, err
+		})
+	}
+}
+
 // WithBool returns a PrepareDecorator that encodes the passed bool into the body of the request
 // and sets the Content-Length header.
 func WithBool(v bool) PrepareDecorator {
--- a/vendor/github.com/Azure/go-autorest/autorest/utility.go
+++ b/vendor/github.com/Azure/go-autorest/autorest/utility.go
@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"io"
 	"net/url"
+	"reflect"
 	"sort"
 	"strings"
 )
@@ -106,6 +107,22 @@ func ensureValueString(value interface{}) string {
 	}
 }

+// MapToValues method converts map[string]interface{} to url.Values.
+func MapToValues(m map[string]interface{}) url.Values {
+	v := url.Values{}
+	for key, value := range m {
+		x := reflect.ValueOf(value)
+		if x.Kind() == reflect.Array || x.Kind() == reflect.Slice {
+			for i := 0; i < x.Len(); i++ {
+				v.Add(key, ensureValueString(x.Index(i)))
+			}
+		} else {
+			v.Add(key, ensureValueString(value))
+		}
+	}
+	return v
+}
+
 // String method converts interface v to string. If interface is a list, it
 // joins list elements using separator.
 func String(v interface{}, sep ...string) string {
--- a/vendor/github.com/Azure/go-autorest/autorest/validation/validation.go
+++ b/vendor/github.com/Azure/go-autorest/autorest/validation/validation.go
@@ -0,0 +1,373 @@
+/*
+Package validation provides methods for validating parameter value using reflection.
+*/
+package validation
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+)
+
+// Constraint stores constraint name, target field name
+// Rule and chain validations.
+type Constraint struct {
+
+	// Target field name for validation.
+	Target string
+
+	// Constraint name e.g. minLength, MaxLength, Pattern, etc.
+	Name string
+
+	// Rule for constraint e.g. greater than 10, less than 5 etc.
+	Rule interface{}
+
+	// Chain Validations for struct type
+	Chain []Constraint
+}
+
+// Validation stores parameter-wise validation.
+type Validation struct {
+	TargetValue interface{}
+	Constraints []Constraint
+}
+
+// Constraint list
+const (
+	Empty            = "Empty"
+	Null             = "Null"
+	ReadOnly         = "ReadOnly"
+	Pattern          = "Pattern"
+	MaxLength        = "MaxLength"
+	MinLength        = "MinLength"
+	MaxItems         = "MaxItems"
+	MinItems         = "MinItems"
+	MultipleOf       = "MultipleOf"
+	UniqueItems      = "UniqueItems"
+	InclusiveMaximum = "InclusiveMaximum"
+	ExclusiveMaximum = "ExclusiveMaximum"
+	ExclusiveMinimum = "ExclusiveMinimum"
+	InclusiveMinimum = "InclusiveMinimum"
+)
+
+// Validate method validates constraints on parameter
+// passed in validation array.
+func Validate(m []Validation) error {
+	for _, item := range m {
+		v := reflect.ValueOf(item.TargetValue)
+		for _, constraint := range item.Constraints {
+			var err error
+			switch v.Kind() {
+			case reflect.Ptr:
+				err = validatePtr(v, constraint)
+			case reflect.String:
+				err = validateString(v, constraint)
+			case reflect.Struct:
+				err = validateStruct(v, constraint)
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				err = validateInt(v, constraint)
+			case reflect.Float32, reflect.Float64:
+				err = validateFloat(v, constraint)
+			case reflect.Array, reflect.Slice, reflect.Map:
+				err = validateArrayMap(v, constraint)
+			default:
+				err = createError(v, constraint, fmt.Sprintf("unknown type %v", v.Kind()))
+			}
+
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func validateStruct(x reflect.Value, v Constraint, name ...string) error {
+	//Get field name from target name which is in format a.b.c
+	s := strings.Split(v.Target, ".")
+	f := x.FieldByName(s[len(s)-1])
+	if isZero(f) {
+		return createError(x, v, fmt.Sprintf("field %q doesn't exist", v.Target))
+	}
+
+	if err := Validate([]Validation{
+		{
+			TargetValue: getInterfaceValue(f),
+			Constraints: []Constraint{v},
+		},
+	}); err != nil {
+		return err
+	}
+	return nil
+}
+
+func validatePtr(x reflect.Value, v Constraint) error {
+	if v.Name == ReadOnly {
+		if !x.IsNil() {
+			return createError(x.Elem(), v, "readonly parameter; must send as nil or empty in request")
+		}
+		return nil
+	}
+	if x.IsNil() {
+		return checkNil(x, v)
+	}
+	if v.Chain != nil {
+		return Validate([]Validation{
+			{
+				TargetValue: getInterfaceValue(x.Elem()),
+				Constraints: v.Chain,
+			},
+		})
+	}
+	return nil
+}
+
+func validateInt(x reflect.Value, v Constraint) error {
+	i := x.Int()
+	r, ok := v.Rule.(int)
+	if !ok {
+		return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.Name, v.Rule))
+	}
+	switch v.Name {
+	case MultipleOf:
+		if i%int64(r) != 0 {
+			return createError(x, v, fmt.Sprintf("value must be a multiple of %v", r))
+		}
+	case ExclusiveMinimum:
+		if i <= int64(r) {
+			return createError(x, v, fmt.Sprintf("value must be greater than %v", r))
+		}
+	case ExclusiveMaximum:
+		if i >= int64(r) {
+			return createError(x, v, fmt.Sprintf("value must be less than %v", r))
+		}
+	case InclusiveMinimum:
+		if i < int64(r) {
+			return createError(x, v, fmt.Sprintf("value must be greater than or equal to %v", r))
+		}
+	case InclusiveMaximum:
+		if i > int64(r) {
+			return createError(x, v, fmt.Sprintf("value must be less than or equal to %v", r))
+		}
+	default:
+		return createError(x, v, fmt.Sprintf("constraint %v is not applicable for type integer", v.Name))
+	}
+	return nil
+}
+
+func validateFloat(x reflect.Value, v Constraint) error {
+	f := x.Float()
+	r, ok := v.Rule.(float64)
+	if !ok {
+		return createError(x, v, fmt.Sprintf("rule must be float value for %v constraint; got: %v", v.Name, v.Rule))
+	}
+	switch v.Name {
+	case ExclusiveMinimum:
+		if f <= r {
+			return createError(x, v, fmt.Sprintf("value must be greater than %v", r))
+		}
+	case ExclusiveMaximum:
+		if f >= r {
+			return createError(x, v, fmt.Sprintf("value must be less than %v", r))
+		}
+	case InclusiveMinimum:
+		if f < r {
+			return createError(x, v, fmt.Sprintf("value must be greater than or equal to %v", r))
+		}
+	case InclusiveMaximum:
+		if f > r {
+			return createError(x, v, fmt.Sprintf("value must be less than or equal to %v", r))
+		}
+	default:
+		return createError(x, v, fmt.Sprintf("constraint %s is not applicable for type float", v.Name))
+	}
+	return nil
+}
+
+func validateString(x reflect.Value, v Constraint) error {
+	s := x.String()
+	switch v.Name {
+	case Empty:
+		if len(s) == 0 {
+			return checkEmpty(x, v)
+		}
+	case Pattern:
+		reg, err := regexp.Compile(v.Rule.(string))
+		if err != nil {
+			return createError(x, v, err.Error())
+		}
+		if !reg.MatchString(s) {
+			return createError(x, v, fmt.Sprintf("value doesn't match pattern %v", v.Rule))
+		}
+	case MaxLength:
+		if _, ok := v.Rule.(int); !ok {
+			return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.Name, v.Rule))
+		}
+		if len(s) > v.Rule.(int) {
+			return createError(x, v, fmt.Sprintf("value length must be less than %v", v.Rule))
+		}
+	case MinLength:
+		if _, ok := v.Rule.(int); !ok {
+			return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.Name, v.Rule))
+		}
+		if len(s) < v.Rule.(int) {
+			return createError(x, v, fmt.Sprintf("value length must be greater than %v", v.Rule))
+		}
+	case ReadOnly:
+		if len(s) > 0 {
+			return createError(reflect.ValueOf(s), v, "readonly parameter; must send as nil or empty in request")
+		}
+	default:
+		return createError(x, v, fmt.Sprintf("constraint %s is not applicable to string type", v.Name))
+	}
+
+	if v.Chain != nil {
+		return Validate([]Validation{
+			{
+				TargetValue: getInterfaceValue(x),
+				Constraints: v.Chain,
+			},
+		})
+	}
+	return nil
+}
+
+func validateArrayMap(x reflect.Value, v Constraint) error {
+	switch v.Name {
+	case Null:
+		if x.IsNil() {
+			return checkNil(x, v)
+		}
+	case Empty:
+		if x.IsNil() || x.Len() == 0 {
+			return checkEmpty(x, v)
+		}
+	case MaxItems:
+		if _, ok := v.Rule.(int); !ok {
+			return createError(x, v, fmt.Sprintf("rule must be integer for %v constraint; got: %v", v.Name, v.Rule))
+		}
+		if x.Len() > v.Rule.(int) {
+			return createError(x, v, fmt.Sprintf("maximum item limit is %v; got: %v", v.Rule, x.Len()))
+		}
+	case MinItems:
+		if _, ok := v.Rule.(int); !ok {
+			return createError(x, v, fmt.Sprintf("rule must be integer for %v constraint; got: %v", v.Name, v.Rule))
+		}
+		if x.Len() < v.Rule.(int) {
+			return createError(x, v, fmt.Sprintf("minimum item limit is %v; got: %v", v.Rule, x.Len()))
+		}
+	case UniqueItems:
+		if x.Kind() == reflect.Array || x.Kind() == reflect.Slice {
+			if !checkForUniqueInArray(x) {
+				return createError(x, v, fmt.Sprintf("all items in parameter %q must be unique; got:%v", v.Target, x))
+			}
+		} else if x.Kind() == reflect.Map {
+			if !checkForUniqueInMap(x) {
+				return createError(x, v, fmt.Sprintf("all items in parameter %q must be unique; got:%v", v.Target, x))
+			}
+		} else {
+			return createError(x, v, fmt.Sprintf("type must be array, slice or map for constraint %v; got: %v", v.Name, x.Kind()))
+		}
+	case ReadOnly:
+		if x.Len() != 0 {
+			return createError(x, v, "readonly parameter; must send as nil or empty in request")
+		}
+	default:
+		return createError(x, v, fmt.Sprintf("constraint %v is not applicable to array, slice and map type", v.Name))
+	}
+
+	if v.Chain != nil {
+		return Validate([]Validation{
+			{
+				TargetValue: getInterfaceValue(x),
+				Constraints: v.Chain,
+			},
+		})
+	}
+	return nil
+}
+
+func checkNil(x reflect.Value, v Constraint) error {
+	if _, ok := v.Rule.(bool); !ok {
+		return createError(x, v, fmt.Sprintf("rule must be bool value for %v constraint; got: %v", v.Name, v.Rule))
+	}
+	if v.Rule.(bool) {
+		return createError(x, v, "value can not be null; required parameter")
+	}
+	return nil
+}
+
+func checkEmpty(x reflect.Value, v Constraint) error {
+	if _, ok := v.Rule.(bool); !ok {
+		return createError(x, v, fmt.Sprintf("rule must be bool value for %v constraint; got: %v", v.Name, v.Rule))
+	}
+
+	if v.Rule.(bool) {
+		return createError(x, v, "value can not be null or empty; required parameter")
+	}
+	return nil
+}
+
+func checkForUniqueInArray(x reflect.Value) bool {
+	if x == reflect.Zero(reflect.TypeOf(x)) || x.Len() == 0 {
+		return false
+	}
+	arrOfInterface := make([]interface{}, x.Len())
+
+	for i := 0; i < x.Len(); i++ {
+		arrOfInterface[i] = x.Index(i).Interface()
+	}
+
+	m := make(map[interface{}]bool)
+	for _, val := range arrOfInterface {
+		if m[val] {
+			return false
+		}
+		m[val] = true
+	}
+	return true
+}
+
+func checkForUniqueInMap(x reflect.Value) bool {
+	if x == reflect.Zero(reflect.TypeOf(x)) || x.Len() == 0 {
+		return false
+	}
+	mapOfInterface := make(map[interface{}]interface{}, x.Len())
+
+	keys := x.MapKeys()
+	for _, k := range keys {
+		mapOfInterface[k.Interface()] = x.MapIndex(k).Interface()
+	}
+
+	m := make(map[interface{}]bool)
+	for _, val := range mapOfInterface {
+		if m[val] {
+			return false
+		}
+		m[val] = true
+	}
+	return true
+}
+
+func getInterfaceValue(x reflect.Value) interface{} {
+	if x.Kind() == reflect.Invalid {
+		return nil
+	}
+	return x.Interface()
+}
+
+func isZero(x interface{}) bool {
+	return x == reflect.Zero(reflect.TypeOf(x)).Interface()
+}
+
+func createError(x reflect.Value, v Constraint, err string) error {
+	return fmt.Errorf("autorest/validation: validation failed: parameter=%s constraint=%s value=%#v details: %s",
+		v.Target, v.Name, getInterfaceValue(x), err)
+}
+
+// NewErrorWithValidationError appends package type and method name in
+// validation error.
+func NewErrorWithValidationError(err error, packageType, method string) error {
+	return fmt.Errorf("%s#%s: Invalid input: %v", packageType, method, err)
+}