tango-tfe/cache/src/tango_cache_client_in.h

#ifndef __TANGO_CACHE_CLIENT_IN_H__
#define __TANGO_CACHE_CLIENT_IN_H__

#include <curl/curl.h>
#include <sys/queue.h>

#include <event2/event.h>  
#include <event.h>
#include <hiredis-vip/async.h>
#include <hiredis-vip/hircluster.h>
#include <cjson/cJSON.h>

#include <MESA/wiredLB.h>
#include "tango_cache_client.h"

#define RESPONSE_HDR_EXPIRES 1
#define RESPONSE_HDR_LAST_MOD 2
#define RESPONSE_HDR_ALL	3

#define CACHE_ALL_MINIO   0 //Ԫ<><D4AA>Ϣ<EFBFBD>Ͷ<EFBFBD><CDB6>󶼴<EFBFBD><F3B6BCB4><EFBFBD>MINIO
#define CACHE_META_REDIS  1 //Ԫ<><D4AA>Ϣ<EFBFBD><CFA2>REDIS<49><53><EFBFBD><EFBFBD><EFBFBD><EFBFBD>MINIO
#define CACHE_SMALL_REDIS 2 //Ԫ<><D4AA>Ϣ<EFBFBD><CFA2>С<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>REDIS<49><53><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>MINIO

enum CACHE_REQUEST_METHOD
{
	CACHE_REQUEST_GET=0,
	CACHE_REQUEST_PUT,
	CACHE_REQUEST_DELETE,
	CACHE_REQUEST_DELETE_MUL,
	CACHE_REQUEST_HEAD,
};

enum GET_OBJECT_STATE
{
	GET_STATE_START=0,
	GET_STATE_DELETE,
	GET_STATE_REDIS_META,
	GET_STATE_REDIS_ALL,
	GET_STATE_REDIS_TRY,
	GET_STATE_END,
};

enum PUT_OBJECT_STATE
{
	PUT_STATE_START=0,
	PUT_STATE_WAIT_START,
	PUT_STATE_PART,
	PUT_STATE_CANCEL,
	PUT_STATE_REDIS_META,
	PUT_STATE_REDIS_ALL,
	PUT_STATE_END,
};

struct easy_string
{
	char* buff;
	size_t len;
	size_t size;
};

struct wiredlb_parameter
{
	char wiredlb_topic[64];
	char wiredlb_datacenter[64];
	char wiredlb_group[64];
	char iplist[4096];//minio<69>б<EFBFBD>
	WLB_handle_t wiredlb;
	u_int32_t wiredlb_override;
	u_int32_t port;
	short wiredlb_ha_port;
};

struct tango_cache_parameter
{
	char bucketname[256];
	char redis_key[256];
	long maximum_host_cnns;
	long transfer_timeout;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	long maximum_pipelines;
	u_int64_t maximum_used_mem;
	u_int32_t maximum_sessions;
	u_int32_t upload_block_size; //minio<69>ֶ<EFBFBD><D6B6>ϴ<EFBFBD><CFB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD>
	time_t relative_ttl; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ч<EFBFBD><D0A7>
	u_int32_t hash_object_key;
	//wiredlb
	int object_store_way; //<2F><>ȡobject<63><74>Ϣ<EFBFBD>ķ<EFBFBD>ʽ
	struct wiredlb_parameter minio;
	char redisaddrs[4096];
	u_int32_t redis_object_maxsize;//С<>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>redisʱ<73><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С
};

struct tango_cache_instance
{
	struct event_base* evbase;
	struct event timer_event;
	CURLM *multi_hd;
	enum CACHE_ERR_CODE error_code;

	int redis_connecting;
	redisClusterAsyncContext *redis_ac;
	char redisaddr[128];

	const struct tango_cache_parameter *param;
	void *runtime_log;
	struct cache_statistics statistic;
};

struct multipart_etag_list
{
	char *etag;
	u_int32_t part_number;
	TAILQ_ENTRY(multipart_etag_list) node;
};

typedef void (redisRedirectMinioCallback)(struct tango_cache_ctx *ctx);

struct cache_ctx_data_get
{
	time_t max_age;
	time_t min_fresh;
	time_t expires;
	time_t last_modify;
	u_int32_t need_hdrs;
	enum GET_OBJECT_STATE state;
	struct easy_string response_tag;
	struct tango_cache_result result;
	redisRedirectMinioCallback *redis_redirect_minio_cb;
};

struct cache_ctx_data_put
{
	struct evbuffer *evbuf;
	size_t upload_length;
	size_t upload_offset;
	char *uploadID;
	char *combine_xml;
	TAILQ_HEAD(__etag_list_head, multipart_etag_list) etag_head;
	cJSON *object_meta;
	enum PUT_OBJECT_STATE state;
	u_int32_t part_index; //<2F><>RESPONSE_HDR_
	u_int32_t object_ttl;
	bool close_state; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ùر<C3B9>
	size_t object_size;
};

struct cache_ctx_multi_delete
{
	u_int32_t succ_num;
	u_int32_t fail_num;
};

struct tango_cache_ctx
{
	CURL *curl;
	struct curl_slist *headers;
	struct promise* promise;
	char error[CURL_ERROR_SIZE];	
	char object_key[256];
	char hostaddr[48];

	enum CACHE_REQUEST_METHOD method;
	enum CACHE_ERR_CODE error_code;
	struct easy_string response;

	bool fail_state;
	enum OBJECT_LOCATION locate; //<2F>ɳ<EFBFBD><C9B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>϶<EFBFBD><CFB6><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><CEBB>
	long res_code;
	
	union{
		struct cache_ctx_data_put put;
		struct cache_ctx_data_get get;
		struct cache_ctx_multi_delete del;
	};
	struct tango_cache_instance *instance;
};

struct curl_socket_data
{
	struct event sock_event;
};

void caculate_sha256(const char *data, unsigned long len, char *result, u_int32_t size);

void easy_string_savedata(struct easy_string *estr, const char *data, size_t len);
void easy_string_destroy(struct easy_string *estr);

void tango_cache_ctx_destroy(struct tango_cache_ctx *ctx, bool callback=true);
void tango_cache_set_fail_state(struct tango_cache_ctx *ctx, enum CACHE_ERR_CODE error_code);
const char *tango_cache_get_errstring(const struct tango_cache_ctx *ctx);

bool sessions_exceeds_limit(struct tango_cache_instance *instance, enum OBJECT_LOCATION where_to_get);

struct tango_cache_ctx *tango_cache_update_prepare(struct tango_cache_instance *instance, 
	         struct future* f, struct tango_cache_meta_put *meta, enum OBJECT_LOCATION maybe_loc);
struct tango_cache_ctx *tango_cache_fetch_prepare(struct tango_cache_instance *instance, 
	         enum CACHE_REQUEST_METHOD method, struct future* f, struct tango_cache_meta_get *meta, enum OBJECT_LOCATION where_to_get);
struct tango_cache_ctx *tango_cache_delete_prepare(struct tango_cache_instance *instance, 
             struct future* f, const char *objkey, const char *minio_addr, const char *bucket);

enum OBJECT_LOCATION tango_cache_object_locate(struct tango_cache_instance *instance, size_t object_size);
void tango_cache_get_object_path(struct tango_cache_ctx *ctx, char *path/*OUT*/, size_t pathsize);
struct tango_cache_ctx *tango_cache_update_once_prepare(struct tango_cache_instance *instance, 
             struct future* f, struct tango_cache_meta_put *meta, size_t object_size, char *path, size_t pathsize);

#endif