Exemple #1
0
// Implements set method
func (enum *Ascii_protocol_enum) set(storage *cache.LRUCache) (string, error) {
	if storage.Set(tools.NewStoredData(enum.data_string, enum.key[0]), enum.flags, enum.exptime, 0) {
		return STORED, nil
	} else {
		return strings.Replace(SERVER_ERROR_TEMP, "%s", "Not enough memory", 1), errors.New("SERVER_ERROR")
	}
}
Exemple #2
0
// Function serialize sub command of stats "settings"
func (s *ServerStat) Settings(storage *cache.LRUCache) map[string]string {
	dict := make(map[string]string)
	dict["maxbytes"] = tools.IntToString(storage.Capacity())
	dict["maxconns"] = tools.IntToString(int64(s.Connections_limit))
	dict["tcpport"] = s.tcp
	dict["udpport"] = s.udp
	dict["verbosity"] = tools.IntToString(int64(s.verbosity))
	dict["num_goroutines"] = tools.IntToString(int64(runtime.NumGoroutine()))
	dict["evictions"] = "on" //TODO: to think about apportunity of another value.
	if storage.Crawler.Enabled() {
		dict["lru_crawler"] = "true"
	} else {
		dict["lru_crawler"] = "false"
	}
	dict["lru_crawler_sleep"] = tools.IntToString(int64(storage.Crawler.Sleep()))
	dict["lru_crawler_tocrawl"] = tools.IntToString(int64(storage.Crawler.ItemsPerRun))
	if s.cas_disabled {
		dict["cas_enabled"] = "false"
	} else {
		dict["cas_enabled"] = "true"
	}
	if s.flush_disabled {
		dict["flush_all_enabled"] = "false"
	} else {
		dict["flush_all_enabled"] = "true"
	}
	return dict
}
Exemple #3
0
// Function serialize statistic of server and storage and returns it as map of strings
func (s *ServerStat) Serialize(storage *cache.LRUCache) map[string]string {
	dict := make(map[string]string)
	dict["pid"] = tools.IntToString(int64(s.pid))
	dict["uptime"] = tools.IntToString(int64(s.uptime()))
	dict["time"] = tools.IntToString(int64(s.time()))
	dict["version"] = tools.VERSION
	dict["pointer_size"] = tools.IntToString(int64(pointer_size))
	secu, mcsecu, secs, mcsecs := s.rusage()
	dict["rusage_user"] = tools.IntToString(secu) + "." + tools.IntToString(mcsecu)
	dict["rusage_system"] = tools.IntToString(secs) + "." + tools.IntToString(mcsecs)
	dict["curr_items"] = tools.IntToString(int64(storage.Stats.Current_items))
	dict["total_items"] = tools.IntToString(int64(storage.Stats.Total_items))
	dict["bytes"] = tools.IntToString(s.bytes(storage.Capacity()))
	dict["curr_connections"] = tools.IntToString(int64(s.Current_connections))
	dict["total_connections"] = tools.IntToString(int64(s.Total_connections))
	dict["evictions"] = tools.IntToString(int64(storage.Stats.Evictions))
	dict["expired_unfetched"] = tools.IntToString(int64(storage.Stats.Expired_unfetched))
	dict["evicted_unfetched"] = tools.IntToString(int64(storage.Stats.Evicted_unfetched))
	dict["bytes_read"] = tools.IntToString(int64(s.Read_bytes))
	dict["bytes_written"] = tools.IntToString(int64(s.Written_bytes))
	dict["goroutines"] = tools.IntToString(int64(runtime.NumGoroutine()))
	dict["crawler_reclaimed"] = tools.IntToString(storage.Stats.Crawler_reclaimed)
	for key, value := range s.Commands {
		dict[key] = tools.IntToString(int64(value))
	}
	return dict
}
Exemple #4
0
// Implementation of Check And Set method
func (enum *Ascii_protocol_enum) cas(storage *cache.LRUCache) (string, error) {
	existed_item := storage.Get(enum.key[0])
	if existed_item != nil {
		if existed_item.Cas_unique == enum.cas_unique && existed_item.Cas_unique != 0 {
			return enum.set(storage)
		}
	}
	return NOT_FOUND, nil
}
Exemple #5
0
// Implements touch method
func (enum *Ascii_protocol_enum) touch(storage *cache.LRUCache) (string, error) {
	if item := storage.Get(enum.key[0]); item == nil {
		return NOT_FOUND, nil
	} else {
		if !storage.Set(item.Cacheable, item.Flags, enum.exptime, item.Cas_unique) {
			return strings.Replace(SERVER_ERROR_TEMP, "%s", "Not enough memory", 1), errors.New("SERVER_ERROR")
		}
		return "TOUCHED\r\n", nil
	}
}
Exemple #6
0
// Serialization of sub command items
func (s *ServerStat) Items(storage *cache.LRUCache) map[string]string {
	dict := make(map[string]string)
	dict["number"] = tools.IntToString(int64(storage.Stats.Current_items))
	dict["age"] = tools.IntToString(time.Now().Unix() - storage.Oldest())
	dict["expired_unfetched"] = tools.IntToString(int64(storage.Stats.Expired_unfetched))
	dict["evicted_unfetched"] = tools.IntToString(int64(storage.Stats.Evicted_unfetched))
	dict["crawler_reclaimed"] = tools.IntToString(storage.Stats.Crawler_reclaimed)
	dict["outofmemory"] = tools.IntToString(storage.Stats.Outofmem)
	return dict
}
Exemple #7
0
// Implements append method
func (enum *Ascii_protocol_enum) append(storage *cache.LRUCache) (string, error) {
	existed_item := storage.Get(enum.key[0])
	if existed_item == nil {
		return NOT_STORED, nil
	}
	existed_data := tools.ExtractStoredData(existed_item.Cacheable)
	if existed_data == nil {
		return NOT_STORED, nil
	}
	return enum.pending(storage, existed_item, append(existed_data, enum.data_string...)) // ...
}
Exemple #8
0
// Implements get method
// Passed boolean param cas - defines of returning cas_unique
func (enum *Ascii_protocol_enum) get(storage *cache.LRUCache, cas bool) (string, error) {
	var result = ""
	for _, value := range enum.key {
		item := storage.Get(value)
		if item != nil {
			data := tools.ExtractStoredData(item.Cacheable)
			if data == nil {
				continue
			}
			result += "VALUE " + value + " " + tools.IntToString(int64(item.Flags)) + " " + tools.IntToString(int64(len(data)))
			if cas {
				cas_id := tools.GenerateCasId()
				storage.SetCas(value, cas_id)
				result += " " + tools.IntToString(cas_id)
			}
			result += "\r\n"
			result += string(data) + "\r\n"
		}
	}
	return result + "END\r\n", nil
}
Exemple #9
0
func (enum *Ascii_protocol_enum) lru_crawler(storage *cache.LRUCache) string {
	switch enum.key[0] {
	case "enable":
		err := storage.EnableCrawler()
		if err != nil {
			return strings.Replace(CLIENT_ERROR_TEMP, "%s", err.Error(), 1)
		}
		return "OK\r\n"
	case "disable":
		storage.DisableCrawler()
		return "OK\r\n"
	case "tocrawl":
		if len(enum.key) < 2 {
			return strings.Replace(CLIENT_ERROR_TEMP, "%s", "Wrong parameters number.", 1)
		}
		amount, err := tools.StringToInt32(enum.key[1])
		if amount <= 0 || err != nil {
			return strings.Replace(CLIENT_ERROR_TEMP, "%s", "Invalid value of passed param.", 1)
		}
		storage.Crawler.ItemsPerRun = uint(amount)
		return "OK\r\n"
	case "sleep":
		if len(enum.key) < 2 {
			return strings.Replace(CLIENT_ERROR_TEMP, "%s", "Wrong parameters number.", 1)
		}
		amount, err := tools.StringToInt32(enum.key[1])
		if err != nil {
			return strings.Replace(CLIENT_ERROR_TEMP, "%s", "Invalid value of passed param.", 1)
		}
		err = storage.Crawler.SetSleep(amount)
		if err != nil {
			return strings.Replace(CLIENT_ERROR_TEMP, "%s", err.Error(), 1)
		}
		return "OK\r\n"
	default:
		return strings.Replace(CLIENT_ERROR_TEMP, "%s", "Command is not implemented.", 1)
	}
}
Exemple #10
0
// Utility method, for joining common parts of incr/decr methods.
// Receives additional param sign, which defines operation: -1 or 1
func (enum *Ascii_protocol_enum) fold(storage *cache.LRUCache, sign int) (string, error) {
	if item := storage.Get(enum.key[0]); item != nil && (sign == 1 || sign == -1) {
		existed_data := tools.ExtractStoredData(item.Cacheable)
		if existed_data != nil {
			evaluated_data_for_existed, err_for_existed := tools.StringToInt64(string(existed_data))
			evaluated_data_for_passed, err_for_passed := tools.StringToUInt64(string(enum.data_string))
			if err_for_existed == nil && err_for_passed == nil {
				var result string
				if sign > 0 {
					result = tools.IntToString(evaluated_data_for_existed + int64(evaluated_data_for_passed))
				} else {
					result = tools.IntToString(evaluated_data_for_existed - int64(evaluated_data_for_passed))
				}
				if storage.Set(tools.NewStoredData([]byte(result), enum.key[0]), item.Flags, item.Exptime, 0) {
					return result + "\r\n", nil
				}
				return strings.Replace(SERVER_ERROR_TEMP, "%s", "Not enough memory", 1), errors.New("SERVER_ERROR")
			}
			return ERROR_TEMP, nil
		}
	}
	return NOT_FOUND, nil
}
Exemple #11
0
// Implements add method
func (enum *Ascii_protocol_enum) add(storage *cache.LRUCache) (string, error) {
	if storage.Get(enum.key[0]) != nil {
		return NOT_STORED, nil
	}
	return enum.set(storage)
}
Exemple #12
0
// Implements flush all method
func (enum *Ascii_protocol_enum) flush_all(storage *cache.LRUCache) (string, error) {
	storage.FlushAll()
	return "OK\r\n", nil
}
Exemple #13
0
// Implements delete method
func (enum *Ascii_protocol_enum) delete(storage *cache.LRUCache) (string, error) {
	if storage.Flush(enum.key[0]) {
		return "DELETED\r\n", nil
	}
	return NOT_FOUND, nil
}