func (c *Client) authenticateChannel(params []byte, member *MemberData) (response []byte, err error) {
channelName, socketId, err := parseAuthRequestParams(params)
if err != nil {
return
}
if err = validateSocketId(&socketId); err != nil {
return
}
stringToSign := strings.Join([]string{socketId, channelName}, ":")
var jsonUserData string
if member != nil {
var _jsonUserData []byte
_jsonUserData, err = json.Marshal(member)
if err != nil {
return
}
jsonUserData = string(_jsonUserData)
stringToSign = strings.Join([]string{stringToSign, jsonUserData}, ":")
}
_response := createAuthMap(c.Key, c.Secret, stringToSign)
if member != nil {
_response["channel_data"] = jsonUserData
}
response, err = json.Marshal(_response)
return
}
// buildURL builds the URL for the operation.
func (s *IndicesExistsTypeService) buildURL() (string, url.Values, error) {
// Build URL
path, err := uritemplates.Expand("/{index}/{type}", map[string]string{
"index": strings.Join(s.index, ","),
"type": strings.Join(s.typ, ","),
})
if err != nil {
return "", url.Values{}, err
}
// Add query string parameters
params := url.Values{}
if s.pretty {
params.Set("pretty", "1")
}
if s.ignoreUnavailable != nil {
params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
}
if s.allowNoIndices != nil {
params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
}
if s.expandWildcards != "" {
params.Set("expand_wildcards", s.expandWildcards)
}
if s.local != nil {
params.Set("local", fmt.Sprintf("%v", *s.local))
}
return path, params, nil
}
// buildURL builds the URL for the operation.
func (s *ClusterStateService) buildURL() (string, url.Values, error) {
// Build URL
metrics := strings.Join(s.metrics, ",")
if metrics == "" {
metrics = "_all"
}
indices := strings.Join(s.indices, ",")
if indices == "" {
indices = "_all"
}
path, err := uritemplates.Expand("/_cluster/state/{metrics}/{indices}", map[string]string{
"metrics": metrics,
"indices": indices,
})
if err != nil {
return "", url.Values{}, err
}
// Add query string parameters
params := url.Values{}
if s.masterTimeout != "" {
params.Set("master_timeout", s.masterTimeout)
}
if s.flatSettings != nil {
params.Set("flat_settings", fmt.Sprintf("%v", *s.flatSettings))
}
if s.local != nil {
params.Set("local", fmt.Sprintf("%v", *s.local))
}
return path, params, nil
}
func (hood *Hood) createTableSql(model *Model) string {
a := []string{"CREATE TABLE ", model.Table, " ( "}
for i, field := range model.Fields {
b := []string{
field.Name,
hood.Dialect.SqlType(field.Value, field.Size()),
}
if field.NotNull() {
b = append(b, hood.Dialect.KeywordNotNull())
}
if x := field.Default(); x != "" {
b = append(b, hood.Dialect.KeywordDefault(x))
}
if field.PrimaryKey() {
b = append(b, hood.Dialect.KeywordPrimaryKey())
}
if incKeyword := hood.Dialect.KeywordAutoIncrement(); field.PrimaryKey() && incKeyword != "" {
b = append(b, incKeyword)
}
a = append(a, strings.Join(b, " "))
if i < len(model.Fields)-1 {
a = append(a, ", ")
}
}
a = append(a, " )")
return strings.Join(a, "")
}
func verifyCPULimits(expected framework.ContainersCPUSummary, actual framework.NodesCPUSummary) {
if expected == nil {
return
}
var errList []string
for nodeName, perNodeSummary := range actual {
var nodeErrs []string
for cName, expectedResult := range expected {
perContainerSummary, ok := perNodeSummary[cName]
if !ok {
nodeErrs = append(nodeErrs, fmt.Sprintf("container %q: missing", cName))
continue
}
for p, expectedValue := range expectedResult {
actualValue, ok := perContainerSummary[p]
if !ok {
nodeErrs = append(nodeErrs, fmt.Sprintf("container %q: missing percentile %v", cName, p))
continue
}
if actualValue > expectedValue {
nodeErrs = append(nodeErrs, fmt.Sprintf("container %q: expected %.0fth%% usage < %.3f; got %.3f",
cName, p*100, expectedValue, actualValue))
}
}
}
if len(nodeErrs) > 0 {
errList = append(errList, fmt.Sprintf("node %v:\n %s", nodeName, strings.Join(nodeErrs, ", ")))
}
}
if len(errList) > 0 {
framework.Failf("CPU usage exceeding limits:\n %s", strings.Join(errList, "\n"))
}
}
// cors responds to incoming requests and adds the appropriate cors headers
// TODO: corylanou: add the ability to configure this in our config
func cors(inner http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if origin := r.Header.Get("Origin"); origin != "" {
w.Header().Set(`Access-Control-Allow-Origin`, origin)
w.Header().Set(`Access-Control-Allow-Methods`, strings.Join([]string{
`DELETE`,
`GET`,
`OPTIONS`,
`POST`,
`PUT`,
}, ", "))
w.Header().Set(`Access-Control-Allow-Headers`, strings.Join([]string{
`Accept`,
`Accept-Encoding`,
`Authorization`,
`Content-Length`,
`Content-Type`,
`X-CSRF-Token`,
`X-HTTP-Method-Override`,
}, ", "))
}
if r.Method == "OPTIONS" {
return
}
inner.ServeHTTP(w, r)
})
}
// Adds a hook script.
func Add(name string, repos []string, body io.Reader) error {
config_param := "git:bare:template"
if len(repos) > 0 {
config_param = "git:bare:location"
}
path, err := config.GetString(config_param)
if err != nil {
return err
}
s := []string{path, "hooks", name}
scriptPath := strings.Join(s, "/")
if len(repos) > 0 {
for _, repo := range repos {
repo += ".git"
s = []string{path, repo, "hooks", name}
scriptPath = strings.Join(s, "/")
err := createHookFile(scriptPath, body)
if err != nil {
return err
}
}
} else {
return createHookFile(scriptPath, body)
}
return nil
}
func init() {
// log.SetFlags(log.Ltime | log.Lmicroseconds | log.Lshortfile)
log.SetFlags(log.Lshortfile)
vizList := ""
vizHelp := "Visualize: all,none,useful"
for flag := range Viz {
vizHelp += "," + flag
}
flag.StringVar(&runBot, "b", "v8", "Which bot to run\n\t"+strings.Join(BotList(), "\n\t"))
flag.StringVar(&vizList, "V", "", vizHelp)
flag.IntVar(&debugLevel, "d", 0, "Debug level")
flag.StringVar(&mapName, "m", "", "Map file -- Used to validate generated map, hill guessing etc.")
flag.StringVar(&watchPoints, "w", "", "Watch points \"T1:T2@R,C,N[;T1:T2...]\", \":\" will watch everything")
flag.IntVar(&maxTurn, "T", 65535, "Max Turn")
flag.Parse()
if BotGet(runBot) == nil {
log.Printf("Unrecognized bot \"%s\", Registered bots:\n\t%s\n", runBot, strings.Join(BotList(), "\n\t"))
return
}
SetWatcherPrefix(runBot)
SetDebugLevel(debugLevel)
SetViz(vizList, Viz)
}
func sign(auth aws.Auth, method, path string, params url.Values, headers http.Header) {
var host string
for k, v := range headers {
k = strings.ToLower(k)
switch k {
case "host":
host = v[0]
}
}
// set up some defaults used for signing the request
params["AWSAccessKeyId"] = []string{auth.AccessKey}
params["SignatureVersion"] = []string{"2"}
params["SignatureMethod"] = []string{"HmacSHA256"}
// join up all the incoming params
var sarray []string
for k, v := range params {
sarray = append(sarray, aws.Encode(k)+"="+aws.Encode(v[0]))
}
sort.StringSlice(sarray).Sort()
joined := strings.Join(sarray, "&")
// create the payload, sign it and create the signature
payload := strings.Join([]string{method, host, "/", joined}, "\n")
hash := hmac.New(sha256.New, []byte(auth.SecretKey))
hash.Write([]byte(payload))
signature := make([]byte, b64.EncodedLen(hash.Size()))
b64.Encode(signature, hash.Sum(nil))
// add the signature to the outgoing params
params["Signature"] = []string{string(signature)}
}
func generatePreflightHeaders(c Config) http.Header {
headers := make(http.Header)
if c.AllowCredentials {
headers.Set("Access-Control-Allow-Credentials", "true")
}
if len(c.AllowMethods) > 0 {
allowMethods := convert(normalize(c.AllowMethods), strings.ToUpper)
value := strings.Join(allowMethods, ",")
headers.Set("Access-Control-Allow-Methods", value)
}
if len(c.AllowHeaders) > 0 {
allowHeaders := convert(normalize(c.AllowHeaders), http.CanonicalHeaderKey)
value := strings.Join(allowHeaders, ",")
headers.Set("Access-Control-Allow-Headers", value)
}
if c.MaxAge > time.Duration(0) {
value := strconv.FormatInt(int64(c.MaxAge/time.Second), 10)
headers.Set("Access-Control-Max-Age", value)
}
if c.AllowAllOrigins {
headers.Set("Access-Control-Allow-Origin", "*")
} else {
// Always set Vary headers
// see https://github.com/rs/cors/issues/10,
// https://github.com/rs/cors/commit/dbdca4d95feaa7511a46e6f1efb3b3aa505bc43f#commitcomment-12352001
headers.Add("Vary", "Origin")
headers.Add("Vary", "Access-Control-Request-Method")
headers.Add("Vary", "Access-Control-Request-Headers")
}
return headers
}
func runListUnits(args []string) (exit int) {
if listUnitsFieldsFlag == "" {
stderr("Must define output format")
return 1
}
cols := strings.Split(listUnitsFieldsFlag, ",")
for _, s := range cols {
if _, ok := listUnitsFields[s]; !ok {
stderr("Invalid key in output format: %q", s)
return 1
}
}
states, err := cAPI.UnitStates()
if err != nil {
stderr("Error retrieving list of units from repository: %v", err)
return 1
}
if !sharedFlags.NoLegend {
fmt.Fprintln(out, strings.ToUpper(strings.Join(cols, "\t")))
}
for _, us := range states {
var f []string
for _, c := range cols {
f = append(f, listUnitsFields[c](us, sharedFlags.Full))
}
fmt.Fprintln(out, strings.Join(f, "\t"))
}
out.Flush()
return
}
func runCommand(name string, args ...string) error {
glog.Infof("Running command: %v %v", name, strings.Join(args, " "))
cmd := exec.Command("sh", "-c", strings.Join(append([]string{name}, args...), " "))
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd.Run()
}
func normalizeRegistry(address string) string {
logger := util.RootLogger().WithField("Logger", "Docker")
if address == "" {
logger.Debugln("No registry address provided, using https://registry.hub.docker.com")
return "https://registry.hub.docker.com/v1/"
}
parsed, err := url.Parse(address)
if err != nil {
logger.Errorln("Registry address is invalid, this will probably fail:", address)
return address
}
if parsed.Scheme != "https" {
logger.Warnln("Registry address is expected to begin with 'https://', forcing it to use https")
parsed.Scheme = "https"
address = parsed.String()
}
if strings.HasSuffix(address, "/") {
address = address[:len(address)-1]
}
parts := strings.Split(address, "/")
possiblyAPIVersionStr := parts[len(parts)-1]
// we only support v1, so...
if possiblyAPIVersionStr == "v2" {
logger.Warnln("Registry API v2 not supported, using v1")
newParts := append(parts[:len(parts)-1], "v1")
address = strings.Join(newParts, "/")
} else if possiblyAPIVersionStr != "v1" {
newParts := append(parts, "v1")
address = strings.Join(newParts, "/")
}
return address + "/"
}
func whereEqMap(m map[string]interface{}) (sql string, args []interface{}, err error) {
var exprs []string
for key, val := range m {
expr := ""
if val == nil {
expr = fmt.Sprintf("%s IS NULL", key)
} else {
valVal := reflect.ValueOf(val)
if valVal.Kind() == reflect.Array || valVal.Kind() == reflect.Slice {
placeholders := make([]string, valVal.Len())
for i := 0; i < valVal.Len(); i++ {
placeholders[i] = "?"
args = append(args, valVal.Index(i).Interface())
}
placeholdersStr := strings.Join(placeholders, ",")
expr = fmt.Sprintf("%s IN (%s)", key, placeholdersStr)
} else {
expr = fmt.Sprintf("%s = ?", key)
args = append(args, val)
}
}
exprs = append(exprs, expr)
}
sql = strings.Join(exprs, " AND ")
return
}
func (cmd *esxcli) formatTable(res *Response) {
fields := res.Info.Hints.Fields()
tw := tabwriter.NewWriter(os.Stdout, len(fields), 0, 2, ' ', 0)
var hr []string
for _, name := range fields {
hr = append(hr, strings.Repeat("-", len(name)))
}
fmt.Fprintln(tw, strings.Join(fields, "\t"))
fmt.Fprintln(tw, strings.Join(hr, "\t"))
for _, vals := range res.Values {
var row []string
for _, name := range fields {
key := strings.Replace(name, " ", "", -1)
if val, ok := vals[key]; ok {
row = append(row, strings.Join(val, ", "))
} else {
row = append(row, "")
}
}
fmt.Fprintln(tw, strings.Join(row, "\t"))
}
_ = tw.Flush()
}
func (options *xml2) AttrString(i *inlineAttr) string {
if i == nil {
return ""
}
s := ""
if i.id != "" {
s = " anchor=\"" + i.id + "\""
}
keys := i.SortClasses()
if len(keys) > 0 {
s += " class=\"" + strings.Join(keys, " ") + "\""
}
keys = i.SortAttributes()
attr := make([]string, len(keys))
for j, k := range keys {
v := i.attr[k]
attr[j] = k + "=\"" + v + "\""
}
if len(keys) > 0 {
s += " " + strings.Join(attr, " ")
}
return s
}
func TestMessage(t *testing.T) {
i := 0
sendMail = func(addr string, a smtp.Auth, from string, to []string, msg []byte) error {
if i > len(expected) {
t.Fatalf("Only %d mails should be sent", len(expected))
}
want := expected[i]
if addr != want.addr {
t.Errorf("Invalid address, got %q, want %q", addr, want.addr)
}
if from != want.from {
t.Errorf("Invalid from, got %q, want %q", from, want.from)
}
gotTo := strings.Join(to, ", ")
wantTo := strings.Join(want.to, ", ")
if gotTo != wantTo {
t.Errorf("Invalid recipient, got %q, want %q", gotTo, wantTo)
}
gotMsg := string(msg)
if gotMsg != want.msg {
t.Errorf("Invalid message body, got:\r\n%s\r\nwant:\r\n%s\r\n", gotMsg, want.msg)
}
i++
return nil
}
err := testMailer.Send(&mail.Message{Header: testHeader, Body: testBody})
if err != nil {
t.Error(err)
}
}
// Start launches a master. It will error if possible, but some background processes may still
// be running and the process should exit after it finishes.
func (m *Master) Start() error {
// Allow privileged containers
// TODO: make this configurable and not the default https://github.com/openshift/origin/issues/662
capabilities.Initialize(capabilities.Capabilities{
AllowPrivileged: true,
PrivilegedSources: capabilities.PrivilegedSources{
HostNetworkSources: []string{kubelettypes.ApiserverSource, kubelettypes.FileSource},
HostPIDSources: []string{kubelettypes.ApiserverSource, kubelettypes.FileSource},
HostIPCSources: []string{kubelettypes.ApiserverSource, kubelettypes.FileSource},
},
})
openshiftConfig, err := origin.BuildMasterConfig(*m.config)
if err != nil {
return err
}
kubeMasterConfig, err := BuildKubernetesMasterConfig(openshiftConfig)
if err != nil {
return err
}
switch {
case m.api:
glog.Infof("Starting master on %s (%s)", m.config.ServingInfo.BindAddress, version.Get().String())
glog.Infof("Public master address is %s", m.config.AssetConfig.MasterPublicURL)
if len(m.config.DisabledFeatures) > 0 {
glog.V(4).Infof("Disabled features: %s", strings.Join(m.config.DisabledFeatures, ", "))
}
glog.Infof("Using images from %q", openshiftConfig.ImageFor("<component>"))
if err := StartAPI(openshiftConfig, kubeMasterConfig); err != nil {
return err
}
case m.controllers:
glog.Infof("Starting controllers on %s (%s)", m.config.ServingInfo.BindAddress, version.Get().String())
if len(m.config.DisabledFeatures) > 0 {
glog.V(4).Infof("Disabled features: %s", strings.Join(m.config.DisabledFeatures, ", "))
}
glog.Infof("Using images from %q", openshiftConfig.ImageFor("<component>"))
if err := startHealth(openshiftConfig); err != nil {
return err
}
}
if m.controllers {
// run controllers asynchronously (not required to be "ready")
go func() {
if err := startControllers(openshiftConfig, kubeMasterConfig); err != nil {
glog.Fatal(err)
}
openshiftConfig.Informers.Start(utilwait.NeverStop)
}()
}
return nil
}
func TestPersistentFlags(t *testing.T) {
fullSetupTest("echo -s something -p more here")
// persistentFlag should act like normal flag on it's own command
if strings.Join(te, " ") != "more here" {
t.Errorf("flags didn't leave proper args remaining..%s given", te)
}
if flags1 != "something" {
t.Errorf("string flag didn't get correct value, had %v", flags1)
}
if !flagbp {
t.Errorf("persistent bool flag not parsed correctly. Expected true, had %v", flagbp)
}
// persistentFlag should act like normal flag on it's own command
fullSetupTest("echo times -s again -c -p test here")
if strings.Join(tt, " ") != "test here" {
t.Errorf("flags didn't leave proper args remaining..%s given", tt)
}
if flags1 != "again" {
t.Errorf("string flag didn't get correct value, had %v", flags1)
}
if !flagb2 {
t.Errorf("local flag not parsed correctly. Expected true, had %v", flagb2)
}
if !flagbp {
t.Errorf("persistent bool flag not parsed correctly. Expected true, had %v", flagbp)
}
}
func (r SearchRequest) Path() string {
switch true {
case len(r.Params.Indices) == 0 && len(r.Params.Types) == 0:
return fmt.Sprintf(
"/_search", // all indices, all types
)
case len(r.Params.Indices) > 0 && len(r.Params.Types) == 0:
return fmt.Sprintf(
"/%s/_search",
strings.Join(r.Params.Indices, ","),
)
case len(r.Params.Indices) == 0 && len(r.Params.Types) > 0:
return fmt.Sprintf(
"/_all/%s/_search",
strings.Join(r.Params.Types, ","),
)
case len(r.Params.Indices) > 0 && len(r.Params.Types) > 0:
return fmt.Sprintf(
"/%s/%s/_search",
strings.Join(r.Params.Indices, ","),
strings.Join(r.Params.Types, ","),
)
}
panic("unreachable")
}
func (hood *Hood) querySql() string {
query := make([]string, 0, 20)
if hood.selector != "" {
query = append(query, hood.selector)
}
for _, join := range hood.joins {
query = append(query, join)
}
if x := hood.where; len(x) > 0 {
query = append(query, fmt.Sprintf("WHERE %v", strings.Join(x, " AND ")))
}
if x := hood.groupBy; x != "" {
query = append(query, x)
}
if x := hood.having; x != "" {
query = append(query, x)
}
if x := hood.orderBy; x != "" {
query = append(query, x)
}
if x := hood.limit; x != "" {
query = append(query, x)
}
if x := hood.offset; x != "" {
query = append(query, x)
}
return hood.substituteMarkers(strings.Join(query, " "))
}
// Execute DML statements in bootstrap stage.
// All the statements run in a single transaction.
func doDMLWorks(s Session) {
mustExecute(s, "BEGIN")
// Insert a default user with empty password.
mustExecute(s, `INSERT INTO mysql.user VALUES
("localhost", "root", "", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y"),
("127.0.0.1", "root", "", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y"),
("::1", "root", "", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y");`)
// Init global system variable table.
values := make([]string, 0, len(variable.SysVars))
for k, v := range variable.SysVars {
value := fmt.Sprintf(`("%s", "%s")`, strings.ToLower(k), v.Value)
values = append(values, value)
}
sql := fmt.Sprintf("INSERT INTO %s.%s VALUES %s;", mysql.SystemDB, mysql.GlobalVariablesTable,
strings.Join(values, ", "))
mustExecute(s, sql)
// Init global status variable table.
values = make([]string, 0, len(variable.StatusVars))
for k, v := range variable.StatusVars {
value := fmt.Sprintf(`("%s", "%s")`, strings.ToLower(k), v.Value)
values = append(values, value)
}
sql = fmt.Sprintf("INSERT INTO %s.%s VALUES %s;", mysql.SystemDB, mysql.GlobalStatusTable,
strings.Join(values, ", "))
mustExecute(s, sql)
sql = fmt.Sprintf(`INSERT INTO %s.%s VALUES("%s", "%s", "Bootstrap flag. Do not delete.")
ON DUPLICATE KEY UPDATE VARIABLE_VALUE="%s"`,
mysql.SystemDB, mysql.TiDBTable, bootstrappedVar, bootstrappedVarTrue, bootstrappedVarTrue)
mustExecute(s, sql)
mustExecute(s, "COMMIT")
}
func verifyMemoryLimits(c clientset.Interface, expected framework.ResourceUsagePerContainer, actual framework.ResourceUsagePerNode) {
if expected == nil {
return
}
var errList []string
for nodeName, nodeSummary := range actual {
var nodeErrs []string
for cName, expectedResult := range expected {
container, ok := nodeSummary[cName]
if !ok {
nodeErrs = append(nodeErrs, fmt.Sprintf("container %q: missing", cName))
continue
}
expectedValue := expectedResult.MemoryRSSInBytes
actualValue := container.MemoryRSSInBytes
if expectedValue != 0 && actualValue > expectedValue {
nodeErrs = append(nodeErrs, fmt.Sprintf("container %q: expected RSS memory (MB) < %d; got %d",
cName, expectedValue, actualValue))
}
}
if len(nodeErrs) > 0 {
errList = append(errList, fmt.Sprintf("node %v:\n %s", nodeName, strings.Join(nodeErrs, ", ")))
heapStats, err := framework.GetKubeletHeapStats(c, nodeName)
if err != nil {
framework.Logf("Unable to get heap stats from %q", nodeName)
} else {
framework.Logf("Heap stats on %q\n:%v", nodeName, heapStats)
}
}
}
if len(errList) > 0 {
framework.Failf("Memory usage exceeding limits:\n %s", strings.Join(errList, "\n"))
}
}
func (p Value) String() string {
var s string
if p.Variable != "" {
s += p.Variable + " = "
}
if p.Expression != nil {
s += p.Expression.String()
}
switch p.Type {
case Bool:
s += fmt.Sprintf("%t@%d:%s", p.BoolValue, p.Pos.Offset, p.Pos)
case String:
s += fmt.Sprintf("%q@%d:%s", p.StringValue, p.Pos.Offset, p.Pos)
case List:
valueStrings := make([]string, len(p.ListValue))
for i, value := range p.ListValue {
valueStrings[i] = value.String()
}
s += fmt.Sprintf("@%d:%s-%d:%s[%s]", p.Pos.Offset, p.Pos, p.EndPos.Offset, p.EndPos,
strings.Join(valueStrings, ", "))
case Map:
propertyStrings := make([]string, len(p.MapValue))
for i, property := range p.MapValue {
propertyStrings[i] = property.String()
}
s += fmt.Sprintf("@%d:%s-%d:%s{%s}", p.Pos.Offset, p.Pos, p.EndPos.Offset, p.EndPos,
strings.Join(propertyStrings, ", "))
default:
panic(fmt.Errorf("bad property type: %d", p.Type))
}
return s
}
// LimitedSepIdentifier builds an identifier out of multiple parts,
// all as lowercase strings and concatenated with the separator
// Non letters and digits are exchanged with dashes and
// reduced to a maximum of one each. If limit is true only
// 'a' to 'z' and '0' to '9' are allowed.
func LimitedSepIdentifier(sep string, limit bool, parts ...interface{}) string {
iparts := make([]string, 0)
for _, p := range parts {
tmp := strings.Map(func(r rune) rune {
// Check letter and digit.
if unicode.IsLetter(r) || unicode.IsDigit(r) {
lcr := unicode.ToLower(r)
if limit {
// Only 'a' to 'z' and '0' to '9'.
if lcr <= unicode.MaxASCII {
return lcr
} else {
return ' '
}
} else {
// Every char is allowed.
return lcr
}
}
return ' '
}, fmt.Sprintf("%v", p))
// Only use non-empty identifier parts.
if ipart := strings.Join(strings.Fields(tmp), "-"); len(ipart) > 0 {
iparts = append(iparts, ipart)
}
}
return strings.Join(iparts, sep)
}
// mustContainKeys checks that a bucket contains a given set of keys.
func mustContainKeys(b *bolt.Bucket, m map[string]string) {
found := make(map[string]string)
b.ForEach(func(k, _ []byte) error {
found[string(k)] = ""
return nil
})
// Check for keys found in bucket that shouldn't be there.
var keys []string
for k, _ := range found {
if _, ok := m[string(k)]; !ok {
keys = append(keys, k)
}
}
if len(keys) > 0 {
sort.Strings(keys)
panic(fmt.Sprintf("keys found(%d): %s", len(keys), strings.Join(keys, ",")))
}
// Check for keys not found in bucket that should be there.
for k, _ := range m {
if _, ok := found[string(k)]; !ok {
keys = append(keys, k)
}
}
if len(keys) > 0 {
sort.Strings(keys)
panic(fmt.Sprintf("keys not found(%d): %s", len(keys), strings.Join(keys, ",")))
}
}
func (this *DbDumperManager) getPlanFromService() ([]string, error) {
command := []string{"m"}
output, err := this.cliCommand(command...)
if err != nil {
return nil, errors.New(strings.Join(output, "\n"))
}
if len(output) < 4 {
return nil, errors.New(strings.Join(output, "\n"))
}
datasUnparsed := output[4:]
var service string = ""
for _, dataUnparsed := range datasUnparsed {
dataUnparsedSplitted := strings.Split(dataUnparsed, " ")
if dataUnparsedSplitted[0] != this.serviceName {
continue
}
service = dataUnparsed
}
if service == "" {
return nil, errors.New("Cannot found service: " + this.serviceName)
}
planString := strings.TrimPrefix(service, this.serviceName)
planString = strings.TrimSpace(planString)
plans := strings.Split(planString, ", ")
lastPlanString := plans[len(plans)-1]
lastPlan := strings.Split(lastPlanString, " ")
plans[len(plans)-1] = lastPlan[0]
return plans, nil
}
func (b *filterBuilder) field(name string, value interface{}) string {
if name == "id" || name == "_id" {
var val = b.mapInt(value)
if val == nil {
return ""
}
value = val
}
var field = pgMapField(name)
switch t := value.(type) {
case q.In:
var values []string
for _, v := range t {
values = append(values, b.param(v))
}
return fmt.Sprintf("%s IN (%s)", field, strings.Join(values, ","))
case q.NotIn:
var values []string
for _, v := range t {
values = append(values, b.param(v))
}
return fmt.Sprintf("%s NOT IN (%s)", field, strings.Join(values, ","))
case q.Op:
return fmt.Sprintf("%s %s %s", field, sqlop(t.Kind), b.param(t.Value))
default:
return fmt.Sprintf("%s = %s", field, b.param(value))
}
}
func (t *typeValidator) Validate(data interface{}) *Result {
result := new(Result)
result.Inc()
if data == nil || reflect.DeepEqual(reflect.Zero(reflect.TypeOf(data)), reflect.ValueOf(data)) {
if len(t.Type) > 0 && !t.Type.Contains("null") { // TODO: if a property is not required it also passes this
return sErr(errors.InvalidType(t.Path, t.In, strings.Join(t.Type, ","), "null"))
}
return result
}
// check if the type matches, should be used in every validator chain as first item
val := reflect.Indirect(reflect.ValueOf(data))
schType, format := t.schemaInfoForType(data)
isLowerInt := t.Format == "int64" && format == "int32"
isLowerFloat := t.Format == "float64" && format == "float32"
if val.Kind() != reflect.String && t.Format != "" && !(format == t.Format || isLowerInt || isLowerFloat) {
return sErr(errors.InvalidType(t.Path, t.In, t.Format, format))
}
if t.Format != "" && val.Kind() == reflect.String {
return result
}
isFloatInt := schType == "number" && swag.IsFloat64AJSONInteger(val.Float()) && t.Type.Contains("integer")
isIntFloat := schType == "integer" && t.Type.Contains("number")
if !(t.Type.Contains(schType) || isFloatInt || isIntFloat) {
return sErr(errors.InvalidType(t.Path, t.In, strings.Join(t.Type, ","), schType))
}
return result
}
// Load index configurations, and open each index file.
func (col *Col) LoadConf() error {
// Deserialize index configuration from file
config, err := ioutil.ReadFile(col.ConfigFileName)
if err != nil {
return err
}
if string(config) == "" {
col.Config = &Config{}
} else if err = json.Unmarshal(config, &col.Config); err != nil {
return err
}
// Open UID index
col.Config.Indexes = append(col.Config.Indexes, IndexConf{FileName: "_uid", PerBucket: 200, HashBits: 14, IndexedPath: []string{"_uid"}})
// Open indexes
col.StrHT = make(map[string]*file.HashTable)
col.StrIC = make(map[string]*IndexConf)
for i, index := range col.Config.Indexes {
ht, err := file.OpenHash(path.Join(col.Dir, index.FileName), index.HashBits, index.PerBucket)
if err != nil {
return err
}
col.StrHT[strings.Join(index.IndexedPath, ",")] = ht
col.StrIC[strings.Join(index.IndexedPath, ",")] = &col.Config.Indexes[i]
}
return nil
}