Generated 2020-01-01 for ddoscoo.

ddoscoo/CMakeLists.txt

@@ -31,6 +31,12 @@ set(ddoscoo_public_header_model
 	include/alibabacloud/ddoscoo/model/AttachSceneDefenseObjectResult.h
 	include/alibabacloud/ddoscoo/model/ConfigL7RsPolicyRequest.h
 	include/alibabacloud/ddoscoo/model/ConfigL7RsPolicyResult.h
+	include/alibabacloud/ddoscoo/model/ConfigLayer4RemarkRequest.h
+	include/alibabacloud/ddoscoo/model/ConfigLayer4RemarkResult.h
+	include/alibabacloud/ddoscoo/model/ConfigLayer4RuleBakModeRequest.h
+	include/alibabacloud/ddoscoo/model/ConfigLayer4RuleBakModeResult.h
+	include/alibabacloud/ddoscoo/model/ConfigLayer4RulePolicyRequest.h
+	include/alibabacloud/ddoscoo/model/ConfigLayer4RulePolicyResult.h
 	include/alibabacloud/ddoscoo/model/ConfigNetworkRegionBlockRequest.h
 	include/alibabacloud/ddoscoo/model/ConfigNetworkRegionBlockResult.h
 	include/alibabacloud/ddoscoo/model/ConfigNetworkRulesRequest.h
@@ -169,6 +175,8 @@ set(ddoscoo_public_header_model
 	include/alibabacloud/ddoscoo/model/DescribeInstancesResult.h
 	include/alibabacloud/ddoscoo/model/DescribeL7RsPolicyRequest.h
 	include/alibabacloud/ddoscoo/model/DescribeL7RsPolicyResult.h
+	include/alibabacloud/ddoscoo/model/DescribeLayer4RulePolicyRequest.h
+	include/alibabacloud/ddoscoo/model/DescribeLayer4RulePolicyResult.h
 	include/alibabacloud/ddoscoo/model/DescribeLogStoreExistStatusRequest.h
 	include/alibabacloud/ddoscoo/model/DescribeLogStoreExistStatusResult.h
 	include/alibabacloud/ddoscoo/model/DescribeNetworkRegionBlockRequest.h
@@ -213,6 +221,8 @@ set(ddoscoo_public_header_model
 	include/alibabacloud/ddoscoo/model/DescribeSlsOpenStatusResult.h
 	include/alibabacloud/ddoscoo/model/DescribeStsGrantStatusRequest.h
 	include/alibabacloud/ddoscoo/model/DescribeStsGrantStatusResult.h
+	include/alibabacloud/ddoscoo/model/DescribeSystemLogRequest.h
+	include/alibabacloud/ddoscoo/model/DescribeSystemLogResult.h
 	include/alibabacloud/ddoscoo/model/DescribeTagKeysRequest.h
 	include/alibabacloud/ddoscoo/model/DescribeTagKeysResult.h
 	include/alibabacloud/ddoscoo/model/DescribeTagResourcesRequest.h
@@ -344,6 +354,12 @@ set(ddoscoo_src
 	src/model/AttachSceneDefenseObjectResult.cc
 	src/model/ConfigL7RsPolicyRequest.cc
 	src/model/ConfigL7RsPolicyResult.cc
+	src/model/ConfigLayer4RemarkRequest.cc
+	src/model/ConfigLayer4RemarkResult.cc
+	src/model/ConfigLayer4RuleBakModeRequest.cc
+	src/model/ConfigLayer4RuleBakModeResult.cc
+	src/model/ConfigLayer4RulePolicyRequest.cc
+	src/model/ConfigLayer4RulePolicyResult.cc
 	src/model/ConfigNetworkRegionBlockRequest.cc
 	src/model/ConfigNetworkRegionBlockResult.cc
 	src/model/ConfigNetworkRulesRequest.cc
@@ -482,6 +498,8 @@ set(ddoscoo_src
 	src/model/DescribeInstancesResult.cc
 	src/model/DescribeL7RsPolicyRequest.cc
 	src/model/DescribeL7RsPolicyResult.cc
+	src/model/DescribeLayer4RulePolicyRequest.cc
+	src/model/DescribeLayer4RulePolicyResult.cc
 	src/model/DescribeLogStoreExistStatusRequest.cc
 	src/model/DescribeLogStoreExistStatusResult.cc
 	src/model/DescribeNetworkRegionBlockRequest.cc
@@ -526,6 +544,8 @@ set(ddoscoo_src
 	src/model/DescribeSlsOpenStatusResult.cc
 	src/model/DescribeStsGrantStatusRequest.cc
 	src/model/DescribeStsGrantStatusResult.cc
+	src/model/DescribeSystemLogRequest.cc
+	src/model/DescribeSystemLogResult.cc
 	src/model/DescribeTagKeysRequest.cc
 	src/model/DescribeTagKeysResult.cc
 	src/model/DescribeTagResourcesRequest.cc

ddoscoo/include/alibabacloud/ddoscoo/DdoscooClient.h

@@ -32,6 +32,12 @@
 #include "model/AttachSceneDefenseObjectResult.h"
 #include "model/ConfigL7RsPolicyRequest.h"
 #include "model/ConfigL7RsPolicyResult.h"
+#include "model/ConfigLayer4RemarkRequest.h"
+#include "model/ConfigLayer4RemarkResult.h"
+#include "model/ConfigLayer4RuleBakModeRequest.h"
+#include "model/ConfigLayer4RuleBakModeResult.h"
+#include "model/ConfigLayer4RulePolicyRequest.h"
+#include "model/ConfigLayer4RulePolicyResult.h"
 #include "model/ConfigNetworkRegionBlockRequest.h"
 #include "model/ConfigNetworkRegionBlockResult.h"
 #include "model/ConfigNetworkRulesRequest.h"
@@ -170,6 +176,8 @@
 #include "model/DescribeInstancesResult.h"
 #include "model/DescribeL7RsPolicyRequest.h"
 #include "model/DescribeL7RsPolicyResult.h"
+#include "model/DescribeLayer4RulePolicyRequest.h"
+#include "model/DescribeLayer4RulePolicyResult.h"
 #include "model/DescribeLogStoreExistStatusRequest.h"
 #include "model/DescribeLogStoreExistStatusResult.h"
 #include "model/DescribeNetworkRegionBlockRequest.h"
@@ -214,6 +222,8 @@
 #include "model/DescribeSlsOpenStatusResult.h"
 #include "model/DescribeStsGrantStatusRequest.h"
 #include "model/DescribeStsGrantStatusResult.h"
+#include "model/DescribeSystemLogRequest.h"
+#include "model/DescribeSystemLogResult.h"
 #include "model/DescribeTagKeysRequest.h"
 #include "model/DescribeTagKeysResult.h"
 #include "model/DescribeTagResourcesRequest.h"
@@ -356,6 +366,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ConfigL7RsPolicyResult> ConfigL7RsPolicyOutcome;
 			typedef std::future<ConfigL7RsPolicyOutcome> ConfigL7RsPolicyOutcomeCallable;
 			typedef std::function<void(const DdoscooClient*, const Model::ConfigL7RsPolicyRequest&, const ConfigL7RsPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfigL7RsPolicyAsyncHandler;
+			typedef Outcome<Error, Model::ConfigLayer4RemarkResult> ConfigLayer4RemarkOutcome;
+			typedef std::future<ConfigLayer4RemarkOutcome> ConfigLayer4RemarkOutcomeCallable;
+			typedef std::function<void(const DdoscooClient*, const Model::ConfigLayer4RemarkRequest&, const ConfigLayer4RemarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfigLayer4RemarkAsyncHandler;
+			typedef Outcome<Error, Model::ConfigLayer4RuleBakModeResult> ConfigLayer4RuleBakModeOutcome;
+			typedef std::future<ConfigLayer4RuleBakModeOutcome> ConfigLayer4RuleBakModeOutcomeCallable;
+			typedef std::function<void(const DdoscooClient*, const Model::ConfigLayer4RuleBakModeRequest&, const ConfigLayer4RuleBakModeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfigLayer4RuleBakModeAsyncHandler;
+			typedef Outcome<Error, Model::ConfigLayer4RulePolicyResult> ConfigLayer4RulePolicyOutcome;
+			typedef std::future<ConfigLayer4RulePolicyOutcome> ConfigLayer4RulePolicyOutcomeCallable;
+			typedef std::function<void(const DdoscooClient*, const Model::ConfigLayer4RulePolicyRequest&, const ConfigLayer4RulePolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfigLayer4RulePolicyAsyncHandler;
 			typedef Outcome<Error, Model::ConfigNetworkRegionBlockResult> ConfigNetworkRegionBlockOutcome;
 			typedef std::future<ConfigNetworkRegionBlockOutcome> ConfigNetworkRegionBlockOutcomeCallable;
 			typedef std::function<void(const DdoscooClient*, const Model::ConfigNetworkRegionBlockRequest&, const ConfigNetworkRegionBlockOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfigNetworkRegionBlockAsyncHandler;
@@ -563,6 +582,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeL7RsPolicyResult> DescribeL7RsPolicyOutcome;
 			typedef std::future<DescribeL7RsPolicyOutcome> DescribeL7RsPolicyOutcomeCallable;
 			typedef std::function<void(const DdoscooClient*, const Model::DescribeL7RsPolicyRequest&, const DescribeL7RsPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeL7RsPolicyAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLayer4RulePolicyResult> DescribeLayer4RulePolicyOutcome;
+			typedef std::future<DescribeLayer4RulePolicyOutcome> DescribeLayer4RulePolicyOutcomeCallable;
+			typedef std::function<void(const DdoscooClient*, const Model::DescribeLayer4RulePolicyRequest&, const DescribeLayer4RulePolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLayer4RulePolicyAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLogStoreExistStatusResult> DescribeLogStoreExistStatusOutcome;
 			typedef std::future<DescribeLogStoreExistStatusOutcome> DescribeLogStoreExistStatusOutcomeCallable;
 			typedef std::function<void(const DdoscooClient*, const Model::DescribeLogStoreExistStatusRequest&, const DescribeLogStoreExistStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLogStoreExistStatusAsyncHandler;
@@ -629,6 +651,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeStsGrantStatusResult> DescribeStsGrantStatusOutcome;
 			typedef std::future<DescribeStsGrantStatusOutcome> DescribeStsGrantStatusOutcomeCallable;
 			typedef std::function<void(const DdoscooClient*, const Model::DescribeStsGrantStatusRequest&, const DescribeStsGrantStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStsGrantStatusAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSystemLogResult> DescribeSystemLogOutcome;
+			typedef std::future<DescribeSystemLogOutcome> DescribeSystemLogOutcomeCallable;
+			typedef std::function<void(const DdoscooClient*, const Model::DescribeSystemLogRequest&, const DescribeSystemLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSystemLogAsyncHandler;
 			typedef Outcome<Error, Model::DescribeTagKeysResult> DescribeTagKeysOutcome;
 			typedef std::future<DescribeTagKeysOutcome> DescribeTagKeysOutcomeCallable;
 			typedef std::function<void(const DdoscooClient*, const Model::DescribeTagKeysRequest&, const DescribeTagKeysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTagKeysAsyncHandler;
@@ -826,6 +851,15 @@ namespace AlibabaCloud
 			ConfigL7RsPolicyOutcome configL7RsPolicy(const Model::ConfigL7RsPolicyRequest &request)const;
 			void configL7RsPolicyAsync(const Model::ConfigL7RsPolicyRequest& request, const ConfigL7RsPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ConfigL7RsPolicyOutcomeCallable configL7RsPolicyCallable(const Model::ConfigL7RsPolicyRequest& request) const;
+			ConfigLayer4RemarkOutcome configLayer4Remark(const Model::ConfigLayer4RemarkRequest &request)const;
+			void configLayer4RemarkAsync(const Model::ConfigLayer4RemarkRequest& request, const ConfigLayer4RemarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ConfigLayer4RemarkOutcomeCallable configLayer4RemarkCallable(const Model::ConfigLayer4RemarkRequest& request) const;
+			ConfigLayer4RuleBakModeOutcome configLayer4RuleBakMode(const Model::ConfigLayer4RuleBakModeRequest &request)const;
+			void configLayer4RuleBakModeAsync(const Model::ConfigLayer4RuleBakModeRequest& request, const ConfigLayer4RuleBakModeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ConfigLayer4RuleBakModeOutcomeCallable configLayer4RuleBakModeCallable(const Model::ConfigLayer4RuleBakModeRequest& request) const;
+			ConfigLayer4RulePolicyOutcome configLayer4RulePolicy(const Model::ConfigLayer4RulePolicyRequest &request)const;
+			void configLayer4RulePolicyAsync(const Model::ConfigLayer4RulePolicyRequest& request, const ConfigLayer4RulePolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ConfigLayer4RulePolicyOutcomeCallable configLayer4RulePolicyCallable(const Model::ConfigLayer4RulePolicyRequest& request) const;
 			ConfigNetworkRegionBlockOutcome configNetworkRegionBlock(const Model::ConfigNetworkRegionBlockRequest &request)const;
 			void configNetworkRegionBlockAsync(const Model::ConfigNetworkRegionBlockRequest& request, const ConfigNetworkRegionBlockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ConfigNetworkRegionBlockOutcomeCallable configNetworkRegionBlockCallable(const Model::ConfigNetworkRegionBlockRequest& request) const;
@@ -1033,6 +1067,9 @@ namespace AlibabaCloud
 			DescribeL7RsPolicyOutcome describeL7RsPolicy(const Model::DescribeL7RsPolicyRequest &request)const;
 			void describeL7RsPolicyAsync(const Model::DescribeL7RsPolicyRequest& request, const DescribeL7RsPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeL7RsPolicyOutcomeCallable describeL7RsPolicyCallable(const Model::DescribeL7RsPolicyRequest& request) const;
+			DescribeLayer4RulePolicyOutcome describeLayer4RulePolicy(const Model::DescribeLayer4RulePolicyRequest &request)const;
+			void describeLayer4RulePolicyAsync(const Model::DescribeLayer4RulePolicyRequest& request, const DescribeLayer4RulePolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLayer4RulePolicyOutcomeCallable describeLayer4RulePolicyCallable(const Model::DescribeLayer4RulePolicyRequest& request) const;
 			DescribeLogStoreExistStatusOutcome describeLogStoreExistStatus(const Model::DescribeLogStoreExistStatusRequest &request)const;
 			void describeLogStoreExistStatusAsync(const Model::DescribeLogStoreExistStatusRequest& request, const DescribeLogStoreExistStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLogStoreExistStatusOutcomeCallable describeLogStoreExistStatusCallable(const Model::DescribeLogStoreExistStatusRequest& request) const;
@@ -1099,6 +1136,9 @@ namespace AlibabaCloud
 			DescribeStsGrantStatusOutcome describeStsGrantStatus(const Model::DescribeStsGrantStatusRequest &request)const;
 			void describeStsGrantStatusAsync(const Model::DescribeStsGrantStatusRequest& request, const DescribeStsGrantStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeStsGrantStatusOutcomeCallable describeStsGrantStatusCallable(const Model::DescribeStsGrantStatusRequest& request) const;
+			DescribeSystemLogOutcome describeSystemLog(const Model::DescribeSystemLogRequest &request)const;
+			void describeSystemLogAsync(const Model::DescribeSystemLogRequest& request, const DescribeSystemLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSystemLogOutcomeCallable describeSystemLogCallable(const Model::DescribeSystemLogRequest& request) const;
 			DescribeTagKeysOutcome describeTagKeys(const Model::DescribeTagKeysRequest &request)const;
 			void describeTagKeysAsync(const Model::DescribeTagKeysRequest& request, const DescribeTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeTagKeysOutcomeCallable describeTagKeysCallable(const Model::DescribeTagKeysRequest& request) const;

ddoscoo/include/alibabacloud/ddoscoo/model/ConfigLayer4RemarkRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4REMARKREQUEST_H_
+#define ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4REMARKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ddoscoo/DdoscooExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ddoscoo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDOSCOO_EXPORT ConfigLayer4RemarkRequest : public RpcServiceRequest
+			{
+
+			public:
+				ConfigLayer4RemarkRequest();
+				~ConfigLayer4RemarkRequest();
+
+				std::string getListeners()const;
+				void setListeners(const std::string& listeners);
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+
+            private:
+				std::string listeners_;
+				std::string sourceIp_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4REMARKREQUEST_H_

ddoscoo/include/alibabacloud/ddoscoo/model/ConfigLayer4RemarkResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4REMARKRESULT_H_
+#define ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4REMARKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ddoscoo/DdoscooExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ddoscoo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDOSCOO_EXPORT ConfigLayer4RemarkResult : public ServiceResult
+			{
+			public:
+
+
+				ConfigLayer4RemarkResult();
+				explicit ConfigLayer4RemarkResult(const std::string &payload);
+				~ConfigLayer4RemarkResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4REMARKRESULT_H_

ddoscoo/include/alibabacloud/ddoscoo/model/ConfigLayer4RuleBakModeRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEBAKMODEREQUEST_H_
+#define ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEBAKMODEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ddoscoo/DdoscooExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ddoscoo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDOSCOO_EXPORT ConfigLayer4RuleBakModeRequest : public RpcServiceRequest
+			{
+
+			public:
+				ConfigLayer4RuleBakModeRequest();
+				~ConfigLayer4RuleBakModeRequest();
+
+				std::string getBakMode()const;
+				void setBakMode(const std::string& bakMode);
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+				std::string getListeners()const;
+				void setListeners(const std::string& listeners);
+
+            private:
+				std::string bakMode_;
+				std::string sourceIp_;
+				std::string listeners_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEBAKMODEREQUEST_H_

ddoscoo/include/alibabacloud/ddoscoo/model/ConfigLayer4RuleBakModeResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEBAKMODERESULT_H_
+#define ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEBAKMODERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ddoscoo/DdoscooExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ddoscoo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDOSCOO_EXPORT ConfigLayer4RuleBakModeResult : public ServiceResult
+			{
+			public:
+
+
+				ConfigLayer4RuleBakModeResult();
+				explicit ConfigLayer4RuleBakModeResult(const std::string &payload);
+				~ConfigLayer4RuleBakModeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEBAKMODERESULT_H_

ddoscoo/include/alibabacloud/ddoscoo/model/ConfigLayer4RulePolicyRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEPOLICYREQUEST_H_
+#define ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEPOLICYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ddoscoo/DdoscooExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ddoscoo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDOSCOO_EXPORT ConfigLayer4RulePolicyRequest : public RpcServiceRequest
+			{
+
+			public:
+				ConfigLayer4RulePolicyRequest();
+				~ConfigLayer4RulePolicyRequest();
+
+				std::string getListeners()const;
+				void setListeners(const std::string& listeners);
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+
+            private:
+				std::string listeners_;
+				std::string sourceIp_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEPOLICYREQUEST_H_

ddoscoo/include/alibabacloud/ddoscoo/model/ConfigLayer4RulePolicyResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEPOLICYRESULT_H_
+#define ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ddoscoo/DdoscooExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ddoscoo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDOSCOO_EXPORT ConfigLayer4RulePolicyResult : public ServiceResult
+			{
+			public:
+
+
+				ConfigLayer4RulePolicyResult();
+				explicit ConfigLayer4RulePolicyResult(const std::string &payload);
+				~ConfigLayer4RulePolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDOSCOO_MODEL_CONFIGLAYER4RULEPOLICYRESULT_H_

ddoscoo/include/alibabacloud/ddoscoo/model/DescribeDDosAllEventListRequest.h

@@ -35,8 +35,6 @@ namespace AlibabaCloud
 				DescribeDDosAllEventListRequest();
 				~DescribeDDosAllEventListRequest();
 
-				long getEndTime()const;
-				void setEndTime(long endTime);
 				long getStartTime()const;
 				void setStartTime(long startTime);
 				int getPageNumber()const;
@@ -45,15 +43,17 @@ namespace AlibabaCloud
 				void setSourceIp(const std::string& sourceIp);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
+				long getEndTime()const;
+				void setEndTime(long endTime);
 				std::string getEventType()const;
 				void setEventType(const std::string& eventType);
 
             private:
-				long endTime_;
 				long startTime_;
 				int pageNumber_;
 				std::string sourceIp_;
 				int pageSize_;
+				long endTime_;
 				std::string eventType_;
 
 			};

ddoscoo/include/alibabacloud/ddoscoo/model/DescribeDDosAllEventListResult.h

@@ -35,11 +35,13 @@ namespace AlibabaCloud
 				struct AttackEvent
 				{
 					long pps;
+					std::string area;
 					long endTime;
 					std::string eventType;
 					std::string port;
 					std::string ip;
 					long startTime;
+					std::string region;
 					long mbps;
 				};
 

ddoscoo/include/alibabacloud/ddoscoo/model/DescribeInstanceSpecsResult.h

@@ -37,6 +37,7 @@ namespace AlibabaCloud
 					int qpsLimit;
 					int baseBandwidth;
 					int portLimit;
+					int elasticBw;
 					std::string instanceId;
 					int defenseCount;
 					int domainLimit;

ddoscoo/include/alibabacloud/ddoscoo/model/DescribeLayer4RulePolicyRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBELAYER4RULEPOLICYREQUEST_H_
+#define ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBELAYER4RULEPOLICYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ddoscoo/DdoscooExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ddoscoo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDOSCOO_EXPORT DescribeLayer4RulePolicyRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLayer4RulePolicyRequest();
+				~DescribeLayer4RulePolicyRequest();
+
+				std::string getListeners()const;
+				void setListeners(const std::string& listeners);
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+
+            private:
+				std::string listeners_;
+				std::string sourceIp_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBELAYER4RULEPOLICYREQUEST_H_

ddoscoo/include/alibabacloud/ddoscoo/model/DescribeLayer4RulePolicyResult.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBELAYER4RULEPOLICYRESULT_H_
+#define ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBELAYER4RULEPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ddoscoo/DdoscooExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ddoscoo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDOSCOO_EXPORT DescribeLayer4RulePolicyResult : public ServiceResult
+			{
+			public:
+				struct PriRealServersItem
+				{
+					std::string realServer;
+					std::string instanceId;
+					int frontendPort;
+					int currentIndex;
+					std::string protocol;
+					std::string eip;
+				};
+				struct SecRealServersItem
+				{
+					std::string realServer;
+					std::string instanceId;
+					int frontendPort;
+					int currentIndex;
+					std::string protocol;
+					std::string eip;
+				};
+
+
+				DescribeLayer4RulePolicyResult();
+				explicit DescribeLayer4RulePolicyResult(const std::string &payload);
+				~DescribeLayer4RulePolicyResult();
+				std::vector<SecRealServersItem> getSecRealServers()const;
+				std::vector<PriRealServersItem> getPriRealServers()const;
+				std::string getInstanceId()const;
+				int getBackendPort()const;
+				std::string getBakMode()const;
+				int getFrontendPort()const;
+				int getCurrentIndex()const;
+				std::string getForwardProtocol()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SecRealServersItem> secRealServers_;
+				std::vector<PriRealServersItem> priRealServers_;
+				std::string instanceId_;
+				int backendPort_;
+				std::string bakMode_;
+				int frontendPort_;
+				int currentIndex_;
+				std::string forwardProtocol_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBELAYER4RULEPOLICYRESULT_H_

ddoscoo/include/alibabacloud/ddoscoo/model/DescribeSystemLogRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBESYSTEMLOGREQUEST_H_
+#define ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBESYSTEMLOGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ddoscoo/DdoscooExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ddoscoo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDOSCOO_EXPORT DescribeSystemLogRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeSystemLogRequest();
+				~DescribeSystemLogRequest();
+
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getSourceIp()const;
+				void setSourceIp(const std::string& sourceIp);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				std::string getEntityObject()const;
+				void setEntityObject(const std::string& entityObject);
+				int getEntityType()const;
+				void setEntityType(int entityType);
+
+            private:
+				long startTime_;
+				int pageNumber_;
+				std::string sourceIp_;
+				int pageSize_;
+				long endTime_;
+				std::string entityObject_;
+				int entityType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBESYSTEMLOGREQUEST_H_

ddoscoo/include/alibabacloud/ddoscoo/model/DescribeSystemLogResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBESYSTEMLOGRESULT_H_
+#define ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBESYSTEMLOGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ddoscoo/DdoscooExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ddoscoo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDOSCOO_EXPORT DescribeSystemLogResult : public ServiceResult
+			{
+			public:
+				struct SystemLogItem
+				{
+					int entityType;
+					int status;
+					long gmtCreate;
+					std::string opAccount;
+					long gmtModified;
+					std::string opDesc;
+					int opAction;
+					std::string entityObject;
+				};
+
+
+				DescribeSystemLogResult();
+				explicit DescribeSystemLogResult(const std::string &payload);
+				~DescribeSystemLogResult();
+				long getTotal()const;
+				std::vector<SystemLogItem> getSystemLog()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long total_;
+				std::vector<SystemLogItem> systemLog_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDOSCOO_MODEL_DESCRIBESYSTEMLOGRESULT_H_

ddoscoo/include/alibabacloud/ddoscoo/model/DescribeWebRulesResult.h

@@ -56,6 +56,7 @@ namespace AlibabaCloud
 					std::string cname;
 					bool proxyEnabled;
 					bool https2HttpEnable;
+					bool ocspEnabled;
 					std::vector<WebRule::RealServer> realServers;
 					bool http2HttpsEnable;
 					int punishReason;

ddoscoo/include/alibabacloud/ddoscoo/model/ModifyInstanceRemarkRequest.h

@@ -37,15 +37,15 @@ namespace AlibabaCloud
 
 				std::string getRemark()const;
 				void setRemark(const std::string& remark);
-				std::string getInstanceId()const;
-				void setInstanceId(const std::string& instanceId);
 				std::string getSourceIp()const;
 				void setSourceIp(const std::string& sourceIp);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
 
             private:
 				std::string remark_;
-				std::string instanceId_;
 				std::string sourceIp_;
+				std::string instanceId_;
 
 			};
 		}

ddoscoo/src/DdoscooClient.cc

@@ -231,6 +231,114 @@ DdoscooClient::ConfigL7RsPolicyOutcomeCallable DdoscooClient::configL7RsPolicyCa
 	return task->get_future();
 }
 
+DdoscooClient::ConfigLayer4RemarkOutcome DdoscooClient::configLayer4Remark(const ConfigLayer4RemarkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ConfigLayer4RemarkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ConfigLayer4RemarkOutcome(ConfigLayer4RemarkResult(outcome.result()));
+	else
+		return ConfigLayer4RemarkOutcome(outcome.error());
+}
+
+void DdoscooClient::configLayer4RemarkAsync(const ConfigLayer4RemarkRequest& request, const ConfigLayer4RemarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, configLayer4Remark(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DdoscooClient::ConfigLayer4RemarkOutcomeCallable DdoscooClient::configLayer4RemarkCallable(const ConfigLayer4RemarkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ConfigLayer4RemarkOutcome()>>(
+			[this, request]()
+			{
+			return this->configLayer4Remark(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DdoscooClient::ConfigLayer4RuleBakModeOutcome DdoscooClient::configLayer4RuleBakMode(const ConfigLayer4RuleBakModeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ConfigLayer4RuleBakModeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ConfigLayer4RuleBakModeOutcome(ConfigLayer4RuleBakModeResult(outcome.result()));
+	else
+		return ConfigLayer4RuleBakModeOutcome(outcome.error());
+}
+
+void DdoscooClient::configLayer4RuleBakModeAsync(const ConfigLayer4RuleBakModeRequest& request, const ConfigLayer4RuleBakModeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, configLayer4RuleBakMode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DdoscooClient::ConfigLayer4RuleBakModeOutcomeCallable DdoscooClient::configLayer4RuleBakModeCallable(const ConfigLayer4RuleBakModeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ConfigLayer4RuleBakModeOutcome()>>(
+			[this, request]()
+			{
+			return this->configLayer4RuleBakMode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DdoscooClient::ConfigLayer4RulePolicyOutcome DdoscooClient::configLayer4RulePolicy(const ConfigLayer4RulePolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ConfigLayer4RulePolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ConfigLayer4RulePolicyOutcome(ConfigLayer4RulePolicyResult(outcome.result()));
+	else
+		return ConfigLayer4RulePolicyOutcome(outcome.error());
+}
+
+void DdoscooClient::configLayer4RulePolicyAsync(const ConfigLayer4RulePolicyRequest& request, const ConfigLayer4RulePolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, configLayer4RulePolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DdoscooClient::ConfigLayer4RulePolicyOutcomeCallable DdoscooClient::configLayer4RulePolicyCallable(const ConfigLayer4RulePolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ConfigLayer4RulePolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->configLayer4RulePolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DdoscooClient::ConfigNetworkRegionBlockOutcome DdoscooClient::configNetworkRegionBlock(const ConfigNetworkRegionBlockRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2715,6 +2823,42 @@ DdoscooClient::DescribeL7RsPolicyOutcomeCallable DdoscooClient::describeL7RsPoli
 	return task->get_future();
 }
 
+DdoscooClient::DescribeLayer4RulePolicyOutcome DdoscooClient::describeLayer4RulePolicy(const DescribeLayer4RulePolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLayer4RulePolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLayer4RulePolicyOutcome(DescribeLayer4RulePolicyResult(outcome.result()));
+	else
+		return DescribeLayer4RulePolicyOutcome(outcome.error());
+}
+
+void DdoscooClient::describeLayer4RulePolicyAsync(const DescribeLayer4RulePolicyRequest& request, const DescribeLayer4RulePolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLayer4RulePolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DdoscooClient::DescribeLayer4RulePolicyOutcomeCallable DdoscooClient::describeLayer4RulePolicyCallable(const DescribeLayer4RulePolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLayer4RulePolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLayer4RulePolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DdoscooClient::DescribeLogStoreExistStatusOutcome DdoscooClient::describeLogStoreExistStatus(const DescribeLogStoreExistStatusRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3507,6 +3651,42 @@ DdoscooClient::DescribeStsGrantStatusOutcomeCallable DdoscooClient::describeStsG
 	return task->get_future();
 }
 
+DdoscooClient::DescribeSystemLogOutcome DdoscooClient::describeSystemLog(const DescribeSystemLogRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSystemLogOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSystemLogOutcome(DescribeSystemLogResult(outcome.result()));
+	else
+		return DescribeSystemLogOutcome(outcome.error());
+}
+
+void DdoscooClient::describeSystemLogAsync(const DescribeSystemLogRequest& request, const DescribeSystemLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSystemLog(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DdoscooClient::DescribeSystemLogOutcomeCallable DdoscooClient::describeSystemLogCallable(const DescribeSystemLogRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSystemLogOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSystemLog(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DdoscooClient::DescribeTagKeysOutcome DdoscooClient::describeTagKeys(const DescribeTagKeysRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ddoscoo/src/model/ConfigLayer4RemarkRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ddoscoo/model/ConfigLayer4RemarkRequest.h>
+
+using AlibabaCloud::Ddoscoo::Model::ConfigLayer4RemarkRequest;
+
+ConfigLayer4RemarkRequest::ConfigLayer4RemarkRequest() :
+	RpcServiceRequest("ddoscoo", "2020-01-01", "ConfigLayer4Remark")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ConfigLayer4RemarkRequest::~ConfigLayer4RemarkRequest()
+{}
+
+std::string ConfigLayer4RemarkRequest::getListeners()const
+{
+	return listeners_;
+}
+
+void ConfigLayer4RemarkRequest::setListeners(const std::string& listeners)
+{
+	listeners_ = listeners;
+	setParameter("Listeners", listeners);
+}
+
+std::string ConfigLayer4RemarkRequest::getSourceIp()const
+{
+	return sourceIp_;
+}
+
+void ConfigLayer4RemarkRequest::setSourceIp(const std::string& sourceIp)
+{
+	sourceIp_ = sourceIp;
+	setParameter("SourceIp", sourceIp);
+}
+

ddoscoo/src/model/ConfigLayer4RemarkResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ddoscoo/model/ConfigLayer4RemarkResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ddoscoo;
+using namespace AlibabaCloud::Ddoscoo::Model;
+
+ConfigLayer4RemarkResult::ConfigLayer4RemarkResult() :
+	ServiceResult()
+{}
+
+ConfigLayer4RemarkResult::ConfigLayer4RemarkResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ConfigLayer4RemarkResult::~ConfigLayer4RemarkResult()
+{}
+
+void ConfigLayer4RemarkResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

ddoscoo/src/model/ConfigLayer4RuleBakModeRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ddoscoo/model/ConfigLayer4RuleBakModeRequest.h>
+
+using AlibabaCloud::Ddoscoo::Model::ConfigLayer4RuleBakModeRequest;
+
+ConfigLayer4RuleBakModeRequest::ConfigLayer4RuleBakModeRequest() :
+	RpcServiceRequest("ddoscoo", "2020-01-01", "ConfigLayer4RuleBakMode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ConfigLayer4RuleBakModeRequest::~ConfigLayer4RuleBakModeRequest()
+{}
+
+std::string ConfigLayer4RuleBakModeRequest::getBakMode()const
+{
+	return bakMode_;
+}
+
+void ConfigLayer4RuleBakModeRequest::setBakMode(const std::string& bakMode)
+{
+	bakMode_ = bakMode;
+	setParameter("BakMode", bakMode);
+}
+
+std::string ConfigLayer4RuleBakModeRequest::getSourceIp()const
+{
+	return sourceIp_;
+}
+
+void ConfigLayer4RuleBakModeRequest::setSourceIp(const std::string& sourceIp)
+{
+	sourceIp_ = sourceIp;
+	setParameter("SourceIp", sourceIp);
+}
+
+std::string ConfigLayer4RuleBakModeRequest::getListeners()const
+{
+	return listeners_;
+}
+
+void ConfigLayer4RuleBakModeRequest::setListeners(const std::string& listeners)
+{
+	listeners_ = listeners;
+	setParameter("Listeners", listeners);
+}
+

ddoscoo/src/model/ConfigLayer4RuleBakModeResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ddoscoo/model/ConfigLayer4RuleBakModeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ddoscoo;
+using namespace AlibabaCloud::Ddoscoo::Model;
+
+ConfigLayer4RuleBakModeResult::ConfigLayer4RuleBakModeResult() :
+	ServiceResult()
+{}
+
+ConfigLayer4RuleBakModeResult::ConfigLayer4RuleBakModeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ConfigLayer4RuleBakModeResult::~ConfigLayer4RuleBakModeResult()
+{}
+
+void ConfigLayer4RuleBakModeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

ddoscoo/src/model/ConfigLayer4RulePolicyRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ddoscoo/model/ConfigLayer4RulePolicyRequest.h>
+
+using AlibabaCloud::Ddoscoo::Model::ConfigLayer4RulePolicyRequest;
+
+ConfigLayer4RulePolicyRequest::ConfigLayer4RulePolicyRequest() :
+	RpcServiceRequest("ddoscoo", "2020-01-01", "ConfigLayer4RulePolicy")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ConfigLayer4RulePolicyRequest::~ConfigLayer4RulePolicyRequest()
+{}
+
+std::string ConfigLayer4RulePolicyRequest::getListeners()const
+{
+	return listeners_;
+}
+
+void ConfigLayer4RulePolicyRequest::setListeners(const std::string& listeners)
+{
+	listeners_ = listeners;
+	setParameter("Listeners", listeners);
+}
+
+std::string ConfigLayer4RulePolicyRequest::getSourceIp()const
+{
+	return sourceIp_;
+}
+
+void ConfigLayer4RulePolicyRequest::setSourceIp(const std::string& sourceIp)
+{
+	sourceIp_ = sourceIp;
+	setParameter("SourceIp", sourceIp);
+}
+

ddoscoo/src/model/ConfigLayer4RulePolicyResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ddoscoo/model/ConfigLayer4RulePolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ddoscoo;
+using namespace AlibabaCloud::Ddoscoo::Model;
+
+ConfigLayer4RulePolicyResult::ConfigLayer4RulePolicyResult() :
+	ServiceResult()
+{}
+
+ConfigLayer4RulePolicyResult::ConfigLayer4RulePolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ConfigLayer4RulePolicyResult::~ConfigLayer4RulePolicyResult()
+{}
+
+void ConfigLayer4RulePolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

ddoscoo/src/model/DescribeDDosAllEventListRequest.cc

@@ -27,17 +27,6 @@ DescribeDDosAllEventListRequest::DescribeDDosAllEventListRequest() :
 DescribeDDosAllEventListRequest::~DescribeDDosAllEventListRequest()
 {}
 
-long DescribeDDosAllEventListRequest::getEndTime()const
-{
-	return endTime_;
-}
-
-void DescribeDDosAllEventListRequest::setEndTime(long endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", std::to_string(endTime));
-}
-
 long DescribeDDosAllEventListRequest::getStartTime()const
 {
 	return startTime_;
@@ -82,6 +71,17 @@ void DescribeDDosAllEventListRequest::setPageSize(int pageSize)
 	setParameter("PageSize", std::to_string(pageSize));
 }
 
+long DescribeDDosAllEventListRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDDosAllEventListRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", std::to_string(endTime));
+}
+
 std::string DescribeDDosAllEventListRequest::getEventType()const
 {
 	return eventType_;

ddoscoo/src/model/DescribeDDosAllEventListResult.cc

@@ -57,6 +57,10 @@ void DescribeDDosAllEventListResult::parse(const std::string &payload)
 			attackEventsObject.endTime = std::stol(valueAttackEventsAttackEvent["EndTime"].asString());
 		if(!valueAttackEventsAttackEvent["Mbps"].isNull())
 			attackEventsObject.mbps = std::stol(valueAttackEventsAttackEvent["Mbps"].asString());
+		if(!valueAttackEventsAttackEvent["Region"].isNull())
+			attackEventsObject.region = valueAttackEventsAttackEvent["Region"].asString();
+		if(!valueAttackEventsAttackEvent["Area"].isNull())
+			attackEventsObject.area = valueAttackEventsAttackEvent["Area"].asString();
 		attackEvents_.push_back(attackEventsObject);
 	}
 	if(!value["Total"].isNull())

ddoscoo/src/model/DescribeInstanceSpecsResult.cc

@@ -63,6 +63,8 @@ void DescribeInstanceSpecsResult::parse(const std::string &payload)
 			instanceSpecsObject.functionVersion = valueInstanceSpecsInstanceSpec["FunctionVersion"].asString();
 		if(!valueInstanceSpecsInstanceSpec["QpsLimit"].isNull())
 			instanceSpecsObject.qpsLimit = std::stoi(valueInstanceSpecsInstanceSpec["QpsLimit"].asString());
+		if(!valueInstanceSpecsInstanceSpec["ElasticBw"].isNull())
+			instanceSpecsObject.elasticBw = std::stoi(valueInstanceSpecsInstanceSpec["ElasticBw"].asString());
 		instanceSpecs_.push_back(instanceSpecsObject);
 	}
 

ddoscoo/src/model/DescribeLayer4RulePolicyRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ddoscoo/model/DescribeLayer4RulePolicyRequest.h>
+
+using AlibabaCloud::Ddoscoo::Model::DescribeLayer4RulePolicyRequest;
+
+DescribeLayer4RulePolicyRequest::DescribeLayer4RulePolicyRequest() :
+	RpcServiceRequest("ddoscoo", "2020-01-01", "DescribeLayer4RulePolicy")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLayer4RulePolicyRequest::~DescribeLayer4RulePolicyRequest()
+{}
+
+std::string DescribeLayer4RulePolicyRequest::getListeners()const
+{
+	return listeners_;
+}
+
+void DescribeLayer4RulePolicyRequest::setListeners(const std::string& listeners)
+{
+	listeners_ = listeners;
+	setParameter("Listeners", listeners);
+}
+
+std::string DescribeLayer4RulePolicyRequest::getSourceIp()const
+{
+	return sourceIp_;
+}
+
+void DescribeLayer4RulePolicyRequest::setSourceIp(const std::string& sourceIp)
+{
+	sourceIp_ = sourceIp;
+	setParameter("SourceIp", sourceIp);
+}
+

ddoscoo/src/model/DescribeLayer4RulePolicyResult.cc

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ddoscoo/model/DescribeLayer4RulePolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ddoscoo;
+using namespace AlibabaCloud::Ddoscoo::Model;
+
+DescribeLayer4RulePolicyResult::DescribeLayer4RulePolicyResult() :
+	ServiceResult()
+{}
+
+DescribeLayer4RulePolicyResult::DescribeLayer4RulePolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLayer4RulePolicyResult::~DescribeLayer4RulePolicyResult()
+{}
+
+void DescribeLayer4RulePolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPriRealServersNode = value["PriRealServers"]["PriRealServersItem"];
+	for (auto valuePriRealServersPriRealServersItem : allPriRealServersNode)
+	{
+		PriRealServersItem priRealServersObject;
+		if(!valuePriRealServersPriRealServersItem["InstanceId"].isNull())
+			priRealServersObject.instanceId = valuePriRealServersPriRealServersItem["InstanceId"].asString();
+		if(!valuePriRealServersPriRealServersItem["Eip"].isNull())
+			priRealServersObject.eip = valuePriRealServersPriRealServersItem["Eip"].asString();
+		if(!valuePriRealServersPriRealServersItem["FrontendPort"].isNull())
+			priRealServersObject.frontendPort = std::stoi(valuePriRealServersPriRealServersItem["FrontendPort"].asString());
+		if(!valuePriRealServersPriRealServersItem["Protocol"].isNull())
+			priRealServersObject.protocol = valuePriRealServersPriRealServersItem["Protocol"].asString();
+		if(!valuePriRealServersPriRealServersItem["RealServer"].isNull())
+			priRealServersObject.realServer = valuePriRealServersPriRealServersItem["RealServer"].asString();
+		if(!valuePriRealServersPriRealServersItem["CurrentIndex"].isNull())
+			priRealServersObject.currentIndex = std::stoi(valuePriRealServersPriRealServersItem["CurrentIndex"].asString());
+		priRealServers_.push_back(priRealServersObject);
+	}
+	auto allSecRealServersNode = value["SecRealServers"]["SecRealServersItem"];
+	for (auto valueSecRealServersSecRealServersItem : allSecRealServersNode)
+	{
+		SecRealServersItem secRealServersObject;
+		if(!valueSecRealServersSecRealServersItem["InstanceId"].isNull())
+			secRealServersObject.instanceId = valueSecRealServersSecRealServersItem["InstanceId"].asString();
+		if(!valueSecRealServersSecRealServersItem["Eip"].isNull())
+			secRealServersObject.eip = valueSecRealServersSecRealServersItem["Eip"].asString();
+		if(!valueSecRealServersSecRealServersItem["FrontendPort"].isNull())
+			secRealServersObject.frontendPort = std::stoi(valueSecRealServersSecRealServersItem["FrontendPort"].asString());
+		if(!valueSecRealServersSecRealServersItem["Protocol"].isNull())
+			secRealServersObject.protocol = valueSecRealServersSecRealServersItem["Protocol"].asString();
+		if(!valueSecRealServersSecRealServersItem["RealServer"].isNull())
+			secRealServersObject.realServer = valueSecRealServersSecRealServersItem["RealServer"].asString();
+		if(!valueSecRealServersSecRealServersItem["CurrentIndex"].isNull())
+			secRealServersObject.currentIndex = std::stoi(valueSecRealServersSecRealServersItem["CurrentIndex"].asString());
+		secRealServers_.push_back(secRealServersObject);
+	}
+	if(!value["InstanceId"].isNull())
+		instanceId_ = value["InstanceId"].asString();
+	if(!value["FrontendPort"].isNull())
+		frontendPort_ = std::stoi(value["FrontendPort"].asString());
+	if(!value["BackendPort"].isNull())
+		backendPort_ = std::stoi(value["BackendPort"].asString());
+	if(!value["ForwardProtocol"].isNull())
+		forwardProtocol_ = value["ForwardProtocol"].asString();
+	if(!value["BakMode"].isNull())
+		bakMode_ = value["BakMode"].asString();
+	if(!value["CurrentIndex"].isNull())
+		currentIndex_ = std::stoi(value["CurrentIndex"].asString());
+
+}
+
+std::vector<DescribeLayer4RulePolicyResult::SecRealServersItem> DescribeLayer4RulePolicyResult::getSecRealServers()const
+{
+	return secRealServers_;
+}
+
+std::vector<DescribeLayer4RulePolicyResult::PriRealServersItem> DescribeLayer4RulePolicyResult::getPriRealServers()const
+{
+	return priRealServers_;
+}
+
+std::string DescribeLayer4RulePolicyResult::getInstanceId()const
+{
+	return instanceId_;
+}
+
+int DescribeLayer4RulePolicyResult::getBackendPort()const
+{
+	return backendPort_;
+}
+
+std::string DescribeLayer4RulePolicyResult::getBakMode()const
+{
+	return bakMode_;
+}
+
+int DescribeLayer4RulePolicyResult::getFrontendPort()const
+{
+	return frontendPort_;
+}
+
+int DescribeLayer4RulePolicyResult::getCurrentIndex()const
+{
+	return currentIndex_;
+}
+
+std::string DescribeLayer4RulePolicyResult::getForwardProtocol()const
+{
+	return forwardProtocol_;
+}
+

ddoscoo/src/model/DescribeSystemLogRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ddoscoo/model/DescribeSystemLogRequest.h>
+
+using AlibabaCloud::Ddoscoo::Model::DescribeSystemLogRequest;
+
+DescribeSystemLogRequest::DescribeSystemLogRequest() :
+	RpcServiceRequest("ddoscoo", "2020-01-01", "DescribeSystemLog")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeSystemLogRequest::~DescribeSystemLogRequest()
+{}
+
+long DescribeSystemLogRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeSystemLogRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", std::to_string(startTime));
+}
+
+int DescribeSystemLogRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeSystemLogRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeSystemLogRequest::getSourceIp()const
+{
+	return sourceIp_;
+}
+
+void DescribeSystemLogRequest::setSourceIp(const std::string& sourceIp)
+{
+	sourceIp_ = sourceIp;
+	setParameter("SourceIp", sourceIp);
+}
+
+int DescribeSystemLogRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeSystemLogRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+long DescribeSystemLogRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeSystemLogRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", std::to_string(endTime));
+}
+
+std::string DescribeSystemLogRequest::getEntityObject()const
+{
+	return entityObject_;
+}
+
+void DescribeSystemLogRequest::setEntityObject(const std::string& entityObject)
+{
+	entityObject_ = entityObject;
+	setParameter("EntityObject", entityObject);
+}
+
+int DescribeSystemLogRequest::getEntityType()const
+{
+	return entityType_;
+}
+
+void DescribeSystemLogRequest::setEntityType(int entityType)
+{
+	entityType_ = entityType;
+	setParameter("EntityType", std::to_string(entityType));
+}
+

ddoscoo/src/model/DescribeSystemLogResult.cc

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ddoscoo/model/DescribeSystemLogResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ddoscoo;
+using namespace AlibabaCloud::Ddoscoo::Model;
+
+DescribeSystemLogResult::DescribeSystemLogResult() :
+	ServiceResult()
+{}
+
+DescribeSystemLogResult::DescribeSystemLogResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeSystemLogResult::~DescribeSystemLogResult()
+{}
+
+void DescribeSystemLogResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allSystemLogNode = value["SystemLog"]["SystemLogItem"];
+	for (auto valueSystemLogSystemLogItem : allSystemLogNode)
+	{
+		SystemLogItem systemLogObject;
+		if(!valueSystemLogSystemLogItem["GmtCreate"].isNull())
+			systemLogObject.gmtCreate = std::stol(valueSystemLogSystemLogItem["GmtCreate"].asString());
+		if(!valueSystemLogSystemLogItem["GmtModified"].isNull())
+			systemLogObject.gmtModified = std::stol(valueSystemLogSystemLogItem["GmtModified"].asString());
+		if(!valueSystemLogSystemLogItem["EntityType"].isNull())
+			systemLogObject.entityType = std::stoi(valueSystemLogSystemLogItem["EntityType"].asString());
+		if(!valueSystemLogSystemLogItem["EntityObject"].isNull())
+			systemLogObject.entityObject = valueSystemLogSystemLogItem["EntityObject"].asString();
+		if(!valueSystemLogSystemLogItem["OpAction"].isNull())
+			systemLogObject.opAction = std::stoi(valueSystemLogSystemLogItem["OpAction"].asString());
+		if(!valueSystemLogSystemLogItem["OpAccount"].isNull())
+			systemLogObject.opAccount = valueSystemLogSystemLogItem["OpAccount"].asString();
+		if(!valueSystemLogSystemLogItem["OpDesc"].isNull())
+			systemLogObject.opDesc = valueSystemLogSystemLogItem["OpDesc"].asString();
+		if(!valueSystemLogSystemLogItem["Status"].isNull())
+			systemLogObject.status = std::stoi(valueSystemLogSystemLogItem["Status"].asString());
+		systemLog_.push_back(systemLogObject);
+	}
+	if(!value["Total"].isNull())
+		total_ = std::stol(value["Total"].asString());
+
+}
+
+long DescribeSystemLogResult::getTotal()const
+{
+	return total_;
+}
+
+std::vector<DescribeSystemLogResult::SystemLogItem> DescribeSystemLogResult::getSystemLog()const
+{
+	return systemLog_;
+}
+

ddoscoo/src/model/DescribeWebRulesResult.cc

@@ -57,6 +57,8 @@ void DescribeWebRulesResult::parse(const std::string &payload)
 			webRulesObject.sslCiphers = valueWebRulesWebRule["SslCiphers"].asString();
 		if(!valueWebRulesWebRule["Http2Enable"].isNull())
 			webRulesObject.http2Enable = valueWebRulesWebRule["Http2Enable"].asString() == "true";
+		if(!valueWebRulesWebRule["OcspEnabled"].isNull())
+			webRulesObject.ocspEnabled = valueWebRulesWebRule["OcspEnabled"].asString() == "true";
 		if(!valueWebRulesWebRule["Http2HttpsEnable"].isNull())
 			webRulesObject.http2HttpsEnable = valueWebRulesWebRule["Http2HttpsEnable"].asString() == "true";
 		if(!valueWebRulesWebRule["Https2HttpEnable"].isNull())

ddoscoo/src/model/ModifyInstanceRemarkRequest.cc

@@ -38,17 +38,6 @@ void ModifyInstanceRemarkRequest::setRemark(const std::string& remark)
 	setParameter("Remark", remark);
 }
 
-std::string ModifyInstanceRemarkRequest::getInstanceId()const
-{
-	return instanceId_;
-}
-
-void ModifyInstanceRemarkRequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
-}
-
 std::string ModifyInstanceRemarkRequest::getSourceIp()const
 {
 	return sourceIp_;
@@ -60,3 +49,14 @@ void ModifyInstanceRemarkRequest::setSourceIp(const std::string& sourceIp)
 	setParameter("SourceIp", sourceIp);
 }
 
+std::string ModifyInstanceRemarkRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void ModifyInstanceRemarkRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+