Repository: apache/incubator-rocketmq-externals Branch: master Commit: 82c09225e61e Files: 4748 Total size: 45.1 MB Directory structure: gitextract_xsbb2xua/ ├── .github/ │ ├── ISSUE_TEMPLATE.md │ └── PULL_REQUEST_TEMPLATE.md ├── .gitignore ├── .travis.yml ├── README.md ├── dev/ │ └── merge_rocketmq_pr.py ├── docs/ │ └── connect/ │ └── cn/ │ └── README.md ├── logappender/ │ ├── pom.xml │ └── src/ │ ├── main/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── logappender/ │ │ ├── common/ │ │ │ └── ProducerInstance.java │ │ ├── log4j/ │ │ │ └── RocketmqLog4jAppender.java │ │ ├── log4j2/ │ │ │ └── RocketmqLog4j2Appender.java │ │ └── logback/ │ │ └── RocketmqLogbackAppender.java │ └── test/ │ ├── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── logappender/ │ │ ├── AbstractTestCase.java │ │ ├── Log4jPropertiesTest.java │ │ ├── Log4jTest.java │ │ ├── Log4jXmlTest.java │ │ ├── LogbackTest.java │ │ └── log4j2Test.java │ └── resources/ │ ├── log4j-example.properties │ ├── log4j-example.xml │ ├── log4j2-example.xml │ └── logback-example.xml ├── rocketmq-ansible/ │ ├── Rocketmq Ansible Playbook cn.md │ ├── Rocketmq Ansible Playbook en.md │ ├── broker.yml │ ├── exporter.yml │ ├── hosts │ ├── namesrv.yml │ ├── rocketmq.yml │ ├── roles/ │ │ ├── broker/ │ │ │ ├── tasks/ │ │ │ │ └── main.yml │ │ │ ├── templates/ │ │ │ │ ├── broker.conf.j2 │ │ │ │ ├── logback_broker.xml.j2 │ │ │ │ └── mqbroker.service │ │ │ └── vars/ │ │ │ └── main.yml │ │ ├── exporter/ │ │ │ ├── files/ │ │ │ │ └── mqexportershutdown.sh │ │ │ ├── tasks/ │ │ │ │ └── main.yml │ │ │ ├── templates/ │ │ │ │ ├── mqexporter.service │ │ │ │ └── mqexporter.sh.j2 │ │ │ └── vars/ │ │ │ └── main.yml │ │ └── namesrv/ │ │ ├── tasks/ │ │ │ └── main.yml │ │ ├── templates/ │ │ │ ├── logback_namesrv.xml.j2 │ │ │ └── mqnamesrv.service │ │ └── vars/ │ │ └── main.yml │ └── vars/ │ └── main.yml ├── rocketmq-beats-integration/ │ ├── README.md │ └── libbeat/ │ └── outputs/ │ └── rocketmq/ │ ├── LICENSE │ ├── NOTICE │ ├── client.go │ ├── config.go │ └── rocketmq.go ├── rocketmq-cloudevents-binding/ │ ├── pom.xml │ ├── rocketmq-transport-binding.md │ └── src/ │ ├── main/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── cloudevent/ │ │ ├── RocketMQMessageFactory.java │ │ └── impl/ │ │ ├── RocketMQBinaryMessageReader.java │ │ ├── RocketMQHeaders.java │ │ └── RocketMQMessageWriter.java │ └── test/ │ └── java/ │ └── org/ │ └── apache/ │ └── rocketmq/ │ └── cloudevent/ │ ├── RocketMQMessageWriterTest.java │ └── RocketmqMessageFactoryTest.java ├── rocketmq-flume/ │ ├── .gitignore │ ├── LICENSE │ ├── LICENSE-BIN │ ├── NOTICE │ ├── NOTICE-BIN │ ├── README.md │ ├── pom.xml │ ├── rocketmq-flume-sink/ │ │ ├── pom.xml │ │ └── src/ │ │ ├── main/ │ │ │ └── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── flume/ │ │ │ └── ng/ │ │ │ └── sink/ │ │ │ ├── RocketMQSink.java │ │ │ └── RocketMQSinkConstants.java │ │ └── test/ │ │ ├── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── flume/ │ │ │ └── ng/ │ │ │ └── sink/ │ │ │ └── RocketMQSinkTest.java │ │ └── resources/ │ │ └── log4j.properties │ ├── rocketmq-flume-source/ │ │ ├── pom.xml │ │ └── src/ │ │ ├── main/ │ │ │ └── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── flume/ │ │ │ └── ng/ │ │ │ └── source/ │ │ │ ├── RocketMQSource.java │ │ │ └── RocketMQSourceConstants.java │ │ └── test/ │ │ ├── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── flume/ │ │ │ └── ng/ │ │ │ └── source/ │ │ │ └── RocketMQSourceTest.java │ │ └── resources/ │ │ └── log4j.properties │ └── style/ │ ├── copyright/ │ │ ├── Apache.xml │ │ └── profiles_settings.xml │ ├── rmq_checkstyle.xml │ └── rmq_codeStyle.xml ├── rocketmq-hbase/ │ ├── README.md │ ├── pom.xml │ ├── rocketmq-hbase-sink/ │ │ ├── README.md │ │ ├── pom.xml │ │ └── src/ │ │ ├── main/ │ │ │ └── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── hbase/ │ │ │ └── sink/ │ │ │ ├── DataRow.java │ │ │ ├── Replicator.java │ │ │ ├── RocketMQProducer.java │ │ │ └── Transaction.java │ │ └── test/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── sink/ │ │ └── ReplicatorTest.java │ ├── rocketmq-hbase-source/ │ │ ├── LICENSE-BIN │ │ ├── NOTICE-BIN │ │ ├── README.md │ │ ├── pom.xml │ │ └── src/ │ │ ├── main/ │ │ │ ├── assembly/ │ │ │ │ ├── assembly.xml │ │ │ │ └── scripts/ │ │ │ │ ├── start.sh │ │ │ │ └── stop.sh │ │ │ ├── java/ │ │ │ │ └── org/ │ │ │ │ └── apache/ │ │ │ │ └── rocketmq/ │ │ │ │ └── hbase/ │ │ │ │ └── source/ │ │ │ │ ├── Config.java │ │ │ │ ├── HBaseClient.java │ │ │ │ ├── MessageProcessor.java │ │ │ │ ├── RocketMQConsumer.java │ │ │ │ └── RocketMQSource.java │ │ │ └── resources/ │ │ │ ├── logback.xml │ │ │ └── rocketmq_hbase.conf │ │ └── test/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── hbase/ │ │ └── source/ │ │ └── RocketMQSourceTest.java │ └── style/ │ ├── copyright/ │ │ ├── Apache.xml │ │ └── profiles_settings.xml │ ├── rmq_checkstyle.xml │ └── rmq_codeStyle.xml ├── rocketmq-iot-bridge/ │ ├── .gitignore │ ├── README.md │ ├── docs/ │ │ ├── architecture.md │ │ └── index.md │ ├── docs-cn/ │ │ ├── architecture.md │ │ └── index.md │ ├── pom.xml │ ├── src/ │ │ ├── main/ │ │ │ └── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── iot/ │ │ │ ├── MQTTBridge.java │ │ │ ├── common/ │ │ │ │ ├── configuration/ │ │ │ │ │ ├── ChannelConfiguration.java │ │ │ │ │ └── MQTTBridgeConfiguration.java │ │ │ │ ├── data/ │ │ │ │ │ └── Message.java │ │ │ │ └── util/ │ │ │ │ └── MessageUtil.java │ │ │ ├── connection/ │ │ │ │ └── client/ │ │ │ │ ├── Client.java │ │ │ │ ├── ClientManager.java │ │ │ │ └── impl/ │ │ │ │ └── ClientManagerImpl.java │ │ │ ├── example/ │ │ │ │ ├── MqttSampleConsumer.java │ │ │ │ └── MqttSampleProducer.java │ │ │ ├── protocol/ │ │ │ │ └── mqtt/ │ │ │ │ ├── constant/ │ │ │ │ │ └── MqttConstant.java │ │ │ │ ├── data/ │ │ │ │ │ ├── Bridge.java │ │ │ │ │ ├── MqttClient.java │ │ │ │ │ └── Subscription.java │ │ │ │ ├── event/ │ │ │ │ │ └── DisconnectChannelEvent.java │ │ │ │ └── handler/ │ │ │ │ ├── MessageDispatcher.java │ │ │ │ ├── MessageHandler.java │ │ │ │ ├── MqttConnectionHandler.java │ │ │ │ ├── MqttIdleHandler.java │ │ │ │ └── downstream/ │ │ │ │ ├── SendCallback.java │ │ │ │ └── impl/ │ │ │ │ ├── MqttConnectMessageHandler.java │ │ │ │ ├── MqttDisconnectMessageHandler.java │ │ │ │ ├── MqttMessageForwarder.java │ │ │ │ ├── MqttMessageSender.java │ │ │ │ ├── MqttPingreqMessageHandler.java │ │ │ │ ├── MqttPubackMessageHandler.java │ │ │ │ ├── MqttPubcompMessageHandler.java │ │ │ │ ├── MqttPublishMessageHandler.java │ │ │ │ ├── MqttPubrecMessageHandler.java │ │ │ │ ├── MqttPubrelMessageHandler.java │ │ │ │ ├── MqttSubscribeMessageHandler.java │ │ │ │ └── MqttUnsubscribeMessagHandler.java │ │ │ └── storage/ │ │ │ ├── message/ │ │ │ │ ├── MessageStore.java │ │ │ │ └── cache/ │ │ │ │ └── MessageCache.java │ │ │ └── subscription/ │ │ │ ├── SubscriptionStore.java │ │ │ └── impl/ │ │ │ └── InMemorySubscriptionStore.java │ │ └── test/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── iot/ │ │ ├── connection/ │ │ │ └── client/ │ │ │ └── ClientManagerTest.java │ │ ├── integration/ │ │ │ ├── ConsumeMessageIntegrationTest.java │ │ │ ├── ProduceMessageIntegrationTest.java │ │ │ └── PubSubIntegrationTest.java │ │ ├── protocol/ │ │ │ └── mqtt/ │ │ │ └── handler/ │ │ │ ├── MqttConnectionHandlerTest.java │ │ │ ├── MqttDispatcherTest.java │ │ │ ├── MqttIdleHandlerTest.java │ │ │ └── downstream/ │ │ │ ├── AbstractMqttMessageHandlerTest.java │ │ │ ├── MqttConnectMessageHandlerTest.java │ │ │ ├── MqttDisconnectMessageHandlerTest.java │ │ │ ├── MqttMessageForwarderTest.java │ │ │ ├── MqttPingreqMessageHandlerTest.java │ │ │ ├── MqttSubscribeMessageHandlerTest.java │ │ │ └── MqttUnsubscribeMessageHandlerTest.java │ │ └── storage/ │ │ └── subscription/ │ │ └── InMemorySubscriptionTest.java │ └── style/ │ ├── copyright/ │ │ ├── Apache.xml │ │ └── profiles_settings.xml │ ├── rmq_checkstyle.xml │ └── rmq_codeStyle.xml ├── rocketmq-jms/ │ ├── .gitignore │ ├── .travis.yml │ ├── README.md │ ├── core/ │ │ ├── pom.xml │ │ └── src/ │ │ ├── main/ │ │ │ ├── java/ │ │ │ │ └── org/ │ │ │ │ └── apache/ │ │ │ │ └── rocketmq/ │ │ │ │ └── jms/ │ │ │ │ ├── domain/ │ │ │ │ │ ├── CommonConstant.java │ │ │ │ │ ├── CommonContext.java │ │ │ │ │ ├── JmsBaseConnection.java │ │ │ │ │ ├── JmsBaseConnectionFactory.java │ │ │ │ │ ├── JmsBaseConnectionMetaData.java │ │ │ │ │ ├── JmsBaseConstant.java │ │ │ │ │ ├── JmsBaseMessageConsumer.java │ │ │ │ │ ├── JmsBaseMessageProducer.java │ │ │ │ │ ├── JmsBaseSession.java │ │ │ │ │ ├── JmsBaseTopic.java │ │ │ │ │ ├── RMQPushConsumerExt.java │ │ │ │ │ └── message/ │ │ │ │ │ ├── JmsBaseMessage.java │ │ │ │ │ ├── JmsBytesMessage.java │ │ │ │ │ ├── JmsObjectMessage.java │ │ │ │ │ └── JmsTextMessage.java │ │ │ │ └── util/ │ │ │ │ ├── ExceptionUtil.java │ │ │ │ ├── MessageConverter.java │ │ │ │ ├── MsgConvertUtil.java │ │ │ │ └── URISpecParser.java │ │ │ └── resources/ │ │ │ └── application.conf │ │ └── test/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── jms/ │ │ ├── JmsTestListener.java │ │ ├── JmsTestUtil.java │ │ ├── domain/ │ │ │ └── message/ │ │ │ ├── JmsBytesMessageTest.java │ │ │ ├── JmsMessageConvertTest.java │ │ │ ├── JmsObjectMessageTest.java │ │ │ └── JmsTextMessageTest.java │ │ ├── integration/ │ │ │ ├── IntegrationTestBase.java │ │ │ ├── JmsClientIT.java │ │ │ └── JmsConsumerIT.java │ │ └── util/ │ │ └── URISpecParserTest.java │ ├── pom.xml │ ├── spring/ │ │ ├── pom.xml │ │ └── src/ │ │ ├── main/ │ │ │ └── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── jms/ │ │ │ └── spring/ │ │ │ └── SimpleExMessageListenerContainer.java │ │ └── test/ │ │ ├── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── jms/ │ │ │ └── spring/ │ │ │ ├── JmsConsumeIT.java │ │ │ ├── JmsProduceIT.java │ │ │ └── SpringTestBase.java │ │ └── resources/ │ │ ├── consumer.xml │ │ └── producer.xml │ └── style/ │ ├── copyright/ │ │ ├── Apache.xml │ │ └── profiles_settings.xml │ ├── rmq_checkstyle.xml │ └── rmq_codeStyle.xml ├── rocketmq-knative/ │ └── source/ │ ├── Dockerfile.adapter │ ├── Dockerfile.controller │ ├── README.md │ ├── cmd/ │ │ ├── controller/ │ │ │ └── main.go │ │ └── receive_adapter/ │ │ └── main.go │ ├── config/ │ │ ├── 200-serviceaccount.yaml │ │ ├── 201-clusterrole.yaml │ │ ├── 202-clusterrolebinding.yaml │ │ ├── 300-rocketmqsource.yaml │ │ ├── 400-controller-service.yaml │ │ ├── 500-controller.yaml │ │ └── 600-istioegress.yaml │ ├── pkg/ │ │ ├── adapter/ │ │ │ └── adapter.go │ │ ├── apis/ │ │ │ ├── addtoscheme_eventing_v1alpha1.go │ │ │ ├── addtoscheme_sources_v1alpha1.go │ │ │ ├── apis.go │ │ │ └── sources/ │ │ │ ├── group.go │ │ │ └── v1alpha1/ │ │ │ ├── doc.go │ │ │ ├── register.go │ │ │ ├── rocketmqsource_types.go │ │ │ └── zz_generated.deepcopy.go │ │ ├── client/ │ │ │ ├── clientset/ │ │ │ │ └── versioned/ │ │ │ │ ├── clientset.go │ │ │ │ ├── doc.go │ │ │ │ ├── scheme/ │ │ │ │ │ ├── doc.go │ │ │ │ │ └── register.go │ │ │ │ └── typed/ │ │ │ │ └── sources/ │ │ │ │ └── v1alpha1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated_expansion.go │ │ │ │ ├── rocketmqsource.go │ │ │ │ └── sources_client.go │ │ │ ├── informers/ │ │ │ │ └── externalversions/ │ │ │ │ ├── factory.go │ │ │ │ ├── generic.go │ │ │ │ ├── internalinterfaces/ │ │ │ │ │ └── factory_interfaces.go │ │ │ │ └── sources/ │ │ │ │ ├── interface.go │ │ │ │ └── v1alpha1/ │ │ │ │ ├── interface.go │ │ │ │ └── rocketmqsource.go │ │ │ └── listers/ │ │ │ └── sources/ │ │ │ └── v1alpha1/ │ │ │ ├── expansion_generated.go │ │ │ └── rocketmqsource.go │ │ ├── controller/ │ │ │ ├── sdk/ │ │ │ │ ├── finalizers_accessor.go │ │ │ │ ├── provider.go │ │ │ │ ├── reconciler.go │ │ │ │ └── status_accessor.go │ │ │ ├── sinks/ │ │ │ │ ├── sinks.go │ │ │ │ └── sinks_test.go │ │ │ └── testing/ │ │ │ ├── mock_client.go │ │ │ └── table.go │ │ ├── kncloudevents/ │ │ │ └── good_client.go │ │ └── reconciler/ │ │ ├── creds.go │ │ ├── eventtype/ │ │ │ ├── eventtype.go │ │ │ └── resources/ │ │ │ └── eventtype.go │ │ ├── resources/ │ │ │ └── receive_adapter.go │ │ └── rocketmqsource.go │ ├── sample/ │ │ ├── apacherocketmqsource.yaml │ │ └── event-display.yaml │ └── vendor/ │ ├── cloud.google.com/ │ │ └── go/ │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── compute/ │ │ │ └── metadata/ │ │ │ └── metadata.go │ │ ├── iam/ │ │ │ └── iam.go │ │ ├── internal/ │ │ │ ├── optional/ │ │ │ │ └── optional.go │ │ │ └── version/ │ │ │ └── version.go │ │ └── pubsub/ │ │ ├── apiv1/ │ │ │ ├── doc.go │ │ │ ├── path_funcs.go │ │ │ ├── publisher_client.go │ │ │ └── subscriber_client.go │ │ ├── doc.go │ │ ├── flow_controller.go │ │ ├── go18.go │ │ ├── internal/ │ │ │ └── distribution/ │ │ │ └── distribution.go │ │ ├── iterator.go │ │ ├── message.go │ │ ├── not_go18.go │ │ ├── pubsub.go │ │ ├── pullstream.go │ │ ├── service.go │ │ ├── snapshot.go │ │ ├── subscription.go │ │ └── topic.go │ ├── github.com/ │ │ ├── DataDog/ │ │ │ └── zstd/ │ │ │ ├── LICENSE │ │ │ ├── bitstream.h │ │ │ ├── compiler.h │ │ │ ├── cover.c │ │ │ ├── cpu.h │ │ │ ├── divsufsort.c │ │ │ ├── divsufsort.h │ │ │ ├── entropy_common.c │ │ │ ├── error_private.c │ │ │ ├── error_private.h │ │ │ ├── errors.go │ │ │ ├── fse.h │ │ │ ├── fse_compress.c │ │ │ ├── fse_decompress.c │ │ │ ├── huf.h │ │ │ ├── huf_compress.c │ │ │ ├── huf_decompress.c │ │ │ ├── mem.h │ │ │ ├── pool.c │ │ │ ├── pool.h │ │ │ ├── threading.c │ │ │ ├── threading.h │ │ │ ├── xxhash.c │ │ │ ├── xxhash.h │ │ │ ├── zbuff.h │ │ │ ├── zbuff_common.c │ │ │ ├── zbuff_compress.c │ │ │ ├── zbuff_decompress.c │ │ │ ├── zdict.c │ │ │ ├── zdict.h │ │ │ ├── zstd.go │ │ │ ├── zstd.h │ │ │ ├── zstd_common.c │ │ │ ├── zstd_compress.c │ │ │ ├── zstd_compress_internal.h │ │ │ ├── zstd_decompress.c │ │ │ ├── zstd_double_fast.c │ │ │ ├── zstd_double_fast.h │ │ │ ├── zstd_errors.h │ │ │ ├── zstd_fast.c │ │ │ ├── zstd_fast.h │ │ │ ├── zstd_internal.h │ │ │ ├── zstd_lazy.c │ │ │ ├── zstd_lazy.h │ │ │ ├── zstd_ldm.c │ │ │ ├── zstd_ldm.h │ │ │ ├── zstd_legacy.h │ │ │ ├── zstd_opt.c │ │ │ ├── zstd_opt.h │ │ │ ├── zstd_stream.go │ │ │ ├── zstd_v01.c │ │ │ ├── zstd_v01.h │ │ │ ├── zstd_v02.c │ │ │ ├── zstd_v02.h │ │ │ ├── zstd_v03.c │ │ │ ├── zstd_v03.h │ │ │ ├── zstd_v04.c │ │ │ ├── zstd_v04.h │ │ │ ├── zstd_v05.c │ │ │ ├── zstd_v05.h │ │ │ ├── zstd_v06.c │ │ │ ├── zstd_v06.h │ │ │ ├── zstd_v07.c │ │ │ ├── zstd_v07.h │ │ │ ├── zstdmt_compress.c │ │ │ └── zstdmt_compress.h │ │ ├── Shopify/ │ │ │ └── sarama/ │ │ │ ├── LICENSE │ │ │ ├── acl_bindings.go │ │ │ ├── acl_create_request.go │ │ │ ├── acl_create_response.go │ │ │ ├── acl_delete_request.go │ │ │ ├── acl_delete_response.go │ │ │ ├── acl_describe_request.go │ │ │ ├── acl_describe_response.go │ │ │ ├── acl_filter.go │ │ │ ├── acl_types.go │ │ │ ├── add_offsets_to_txn_request.go │ │ │ ├── add_offsets_to_txn_response.go │ │ │ ├── add_partitions_to_txn_request.go │ │ │ ├── add_partitions_to_txn_response.go │ │ │ ├── admin.go │ │ │ ├── alter_configs_request.go │ │ │ ├── alter_configs_response.go │ │ │ ├── api_versions_request.go │ │ │ ├── api_versions_response.go │ │ │ ├── async_producer.go │ │ │ ├── balance_strategy.go │ │ │ ├── broker.go │ │ │ ├── client.go │ │ │ ├── compress.go │ │ │ ├── config.go │ │ │ ├── config_resource_type.go │ │ │ ├── consumer.go │ │ │ ├── consumer_group.go │ │ │ ├── consumer_group_members.go │ │ │ ├── consumer_metadata_request.go │ │ │ ├── consumer_metadata_response.go │ │ │ ├── crc32_field.go │ │ │ ├── create_partitions_request.go │ │ │ ├── create_partitions_response.go │ │ │ ├── create_topics_request.go │ │ │ ├── create_topics_response.go │ │ │ ├── decompress.go │ │ │ ├── delete_groups_request.go │ │ │ ├── delete_groups_response.go │ │ │ ├── delete_records_request.go │ │ │ ├── delete_records_response.go │ │ │ ├── delete_topics_request.go │ │ │ ├── delete_topics_response.go │ │ │ ├── describe_configs_request.go │ │ │ ├── describe_configs_response.go │ │ │ ├── describe_groups_request.go │ │ │ ├── describe_groups_response.go │ │ │ ├── encoder_decoder.go │ │ │ ├── end_txn_request.go │ │ │ ├── end_txn_response.go │ │ │ ├── errors.go │ │ │ ├── fetch_request.go │ │ │ ├── fetch_response.go │ │ │ ├── find_coordinator_request.go │ │ │ ├── find_coordinator_response.go │ │ │ ├── heartbeat_request.go │ │ │ ├── heartbeat_response.go │ │ │ ├── init_producer_id_request.go │ │ │ ├── init_producer_id_response.go │ │ │ ├── join_group_request.go │ │ │ ├── join_group_response.go │ │ │ ├── leave_group_request.go │ │ │ ├── leave_group_response.go │ │ │ ├── length_field.go │ │ │ ├── list_groups_request.go │ │ │ ├── list_groups_response.go │ │ │ ├── message.go │ │ │ ├── message_set.go │ │ │ ├── metadata_request.go │ │ │ ├── metadata_response.go │ │ │ ├── metrics.go │ │ │ ├── mockbroker.go │ │ │ ├── mockresponses.go │ │ │ ├── offset_commit_request.go │ │ │ ├── offset_commit_response.go │ │ │ ├── offset_fetch_request.go │ │ │ ├── offset_fetch_response.go │ │ │ ├── offset_manager.go │ │ │ ├── offset_request.go │ │ │ ├── offset_response.go │ │ │ ├── packet_decoder.go │ │ │ ├── packet_encoder.go │ │ │ ├── partitioner.go │ │ │ ├── prep_encoder.go │ │ │ ├── produce_request.go │ │ │ ├── produce_response.go │ │ │ ├── produce_set.go │ │ │ ├── real_decoder.go │ │ │ ├── real_encoder.go │ │ │ ├── record.go │ │ │ ├── record_batch.go │ │ │ ├── records.go │ │ │ ├── request.go │ │ │ ├── response_header.go │ │ │ ├── sarama.go │ │ │ ├── sasl_authenticate_request.go │ │ │ ├── sasl_authenticate_response.go │ │ │ ├── sasl_handshake_request.go │ │ │ ├── sasl_handshake_response.go │ │ │ ├── sync_group_request.go │ │ │ ├── sync_group_response.go │ │ │ ├── sync_producer.go │ │ │ ├── timestamp.go │ │ │ ├── txn_offset_commit_request.go │ │ │ ├── txn_offset_commit_response.go │ │ │ ├── utils.go │ │ │ ├── zstd_cgo.go │ │ │ └── zstd_fallback.go │ │ ├── aliyun/ │ │ │ └── aliyun-tablestore-go-sdk/ │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── sample/ │ │ │ │ ├── GlobalTableOperation.go │ │ │ │ ├── LocalIndexTableOperation.go │ │ │ │ ├── LocalTransactionOperation.go │ │ │ │ ├── MultipleRowOperation.go │ │ │ │ ├── SearchIndexOperation.go │ │ │ │ ├── SingleRowOperation.go │ │ │ │ ├── StreamOperation.go │ │ │ │ └── TableOperation.go │ │ │ ├── sample.go │ │ │ ├── tablestore/ │ │ │ │ ├── api.go │ │ │ │ ├── api_test.go │ │ │ │ ├── error.go │ │ │ │ ├── error_test.go │ │ │ │ ├── interface.go │ │ │ │ ├── model.go │ │ │ │ ├── ots_header.go │ │ │ │ ├── otsprotocol/ │ │ │ │ │ ├── build_proto.sh │ │ │ │ │ ├── ots_filter.pb.go │ │ │ │ │ ├── ots_filter.proto │ │ │ │ │ ├── search.pb.go │ │ │ │ │ ├── search.proto │ │ │ │ │ ├── table_store.pb.go │ │ │ │ │ └── table_store.proto │ │ │ │ ├── plain_buffer.go │ │ │ │ ├── search/ │ │ │ │ │ ├── collapse.go │ │ │ │ │ ├── query.go │ │ │ │ │ ├── query_bool.go │ │ │ │ │ ├── query_const_score.go │ │ │ │ │ ├── query_exists.go │ │ │ │ │ ├── query_exists_test.go │ │ │ │ │ ├── query_function_score.go │ │ │ │ │ ├── query_geo_bounding_box.go │ │ │ │ │ ├── query_geo_distance.go │ │ │ │ │ ├── query_geo_polygon.go │ │ │ │ │ ├── query_match.go │ │ │ │ │ ├── query_match_phrase.go │ │ │ │ │ ├── query_matchall.go │ │ │ │ │ ├── query_nested.go │ │ │ │ │ ├── query_prefix.go │ │ │ │ │ ├── query_range.go │ │ │ │ │ ├── query_term.go │ │ │ │ │ ├── query_terms.go │ │ │ │ │ ├── query_wildcard.go │ │ │ │ │ ├── search_query.go │ │ │ │ │ ├── sort.go │ │ │ │ │ ├── sort_field.go │ │ │ │ │ ├── sort_geo_distance.go │ │ │ │ │ ├── sort_mode.go │ │ │ │ │ ├── sort_order.go │ │ │ │ │ ├── sort_primary_key.go │ │ │ │ │ ├── sort_score.go │ │ │ │ │ └── variant_types.go │ │ │ │ ├── search_api.go │ │ │ │ ├── search_model.go │ │ │ │ ├── search_model_test.go │ │ │ │ └── util.go │ │ │ ├── timeline/ │ │ │ │ ├── README.md │ │ │ │ ├── error.go │ │ │ │ ├── message.go │ │ │ │ ├── option.go │ │ │ │ ├── promise/ │ │ │ │ │ └── future.go │ │ │ │ ├── sample/ │ │ │ │ │ ├── feed/ │ │ │ │ │ │ ├── feed.go │ │ │ │ │ │ └── main.go │ │ │ │ │ └── im/ │ │ │ │ │ ├── im.go │ │ │ │ │ └── main.go │ │ │ │ ├── scan.go │ │ │ │ ├── store.go │ │ │ │ ├── timeline.go │ │ │ │ ├── timeline_test.go │ │ │ │ └── writer/ │ │ │ │ ├── backoff.go │ │ │ │ ├── writer.go │ │ │ │ └── writer_test.go │ │ │ └── tunnel/ │ │ │ ├── Gopkg.toml │ │ │ ├── README.md │ │ │ ├── api.go │ │ │ ├── api_test.go │ │ │ ├── channel.go │ │ │ ├── channel_test.go │ │ │ ├── checkpointer.go │ │ │ ├── config.go │ │ │ ├── daemon.go │ │ │ ├── daemon_test.go │ │ │ ├── error.go │ │ │ ├── error_test.go │ │ │ ├── header.go │ │ │ ├── mock_api.go │ │ │ ├── model.go │ │ │ ├── processor.go │ │ │ ├── protocol/ │ │ │ │ ├── error.go │ │ │ │ ├── plain_buffer.go │ │ │ │ └── tunnelservice.pb.go │ │ │ ├── sample/ │ │ │ │ ├── backfillTunnel/ │ │ │ │ │ └── main.go │ │ │ │ ├── createTunnel/ │ │ │ │ │ └── main.go │ │ │ │ ├── exactlyOnce/ │ │ │ │ │ └── main.go │ │ │ │ ├── openTunnel/ │ │ │ │ │ └── main.go │ │ │ │ └── schedule/ │ │ │ │ └── main.go │ │ │ ├── state.go │ │ │ ├── state_test.go │ │ │ ├── tunnel.go │ │ │ ├── util.go │ │ │ ├── util_test.go │ │ │ └── worker.go │ │ ├── apache/ │ │ │ ├── camel-k/ │ │ │ │ ├── LICENSE │ │ │ │ ├── NOTICE │ │ │ │ └── pkg/ │ │ │ │ └── apis/ │ │ │ │ └── camel/ │ │ │ │ └── v1alpha1/ │ │ │ │ ├── build_types.go │ │ │ │ ├── camelcatalog_types.go │ │ │ │ ├── camelcatalog_types_support.go │ │ │ │ ├── common_types.go │ │ │ │ ├── common_types_support.go │ │ │ │ ├── doc.go │ │ │ │ ├── integration_types.go │ │ │ │ ├── integration_types_support.go │ │ │ │ ├── integrationcontext_types.go │ │ │ │ ├── integrationcontext_types_support.go │ │ │ │ ├── integrationplatform_types.go │ │ │ │ ├── integrationplatform_types_support.go │ │ │ │ ├── knative/ │ │ │ │ │ ├── types.go │ │ │ │ │ └── types_support.go │ │ │ │ ├── register.go │ │ │ │ ├── zz_generated.deepcopy.go │ │ │ │ └── zz_generated.defaults.go │ │ │ └── rocketmq-client-go/ │ │ │ ├── .github/ │ │ │ │ └── ISSUE_TEMPLATE/ │ │ │ │ └── issue_template.md │ │ │ ├── .golangci.yml │ │ │ ├── .travis.yml │ │ │ ├── CONTRIBUTING.md │ │ │ ├── LICENSE │ │ │ ├── NOTICE │ │ │ ├── PULL_REQUEST_TEMPLATE.md │ │ │ ├── README.md │ │ │ ├── api.go │ │ │ ├── benchmark/ │ │ │ │ ├── consumer.go │ │ │ │ ├── main.go │ │ │ │ ├── message.go │ │ │ │ ├── producer.go │ │ │ │ └── stable.go │ │ │ ├── config.go │ │ │ ├── consumer/ │ │ │ │ ├── consumer.go │ │ │ │ ├── consumer_test.go │ │ │ │ ├── interceptor.go │ │ │ │ ├── lock.go │ │ │ │ ├── mock_offset_store.go │ │ │ │ ├── offset_store.go │ │ │ │ ├── offset_store_test.go │ │ │ │ ├── option.go │ │ │ │ ├── process_queue.go │ │ │ │ ├── pull_consumer.go │ │ │ │ ├── pull_consumer_test.go │ │ │ │ ├── push_consumer.go │ │ │ │ ├── push_consumer_test.go │ │ │ │ ├── statistics.go │ │ │ │ ├── statistics_test.go │ │ │ │ ├── strategy.go │ │ │ │ └── strategy_test.go │ │ │ ├── docs/ │ │ │ │ ├── Introduction.md │ │ │ │ ├── client-design.gliffy │ │ │ │ ├── feature.md │ │ │ │ └── zh/ │ │ │ │ ├── native-design_zh.md │ │ │ │ └── rocketmq-protocol_zh.md │ │ │ ├── errors.go │ │ │ ├── examples/ │ │ │ │ ├── consumer/ │ │ │ │ │ ├── acl/ │ │ │ │ │ │ └── main.go │ │ │ │ │ ├── broadcast/ │ │ │ │ │ │ └── main.go │ │ │ │ │ ├── delay/ │ │ │ │ │ │ └── main.go │ │ │ │ │ ├── interceptor/ │ │ │ │ │ │ └── main.go │ │ │ │ │ ├── namespace/ │ │ │ │ │ │ └── main.go │ │ │ │ │ ├── orderly/ │ │ │ │ │ │ └── main.go │ │ │ │ │ ├── pull/ │ │ │ │ │ │ └── main.go │ │ │ │ │ ├── retry/ │ │ │ │ │ │ ├── concurrent/ │ │ │ │ │ │ │ └── main.go │ │ │ │ │ │ └── order/ │ │ │ │ │ │ └── main.go │ │ │ │ │ ├── simple/ │ │ │ │ │ │ ├── main-consumer.go │ │ │ │ │ │ └── main.go │ │ │ │ │ ├── strategy/ │ │ │ │ │ │ └── main.go │ │ │ │ │ ├── tag/ │ │ │ │ │ │ └── main.go │ │ │ │ │ └── trace/ │ │ │ │ │ └── main.go │ │ │ │ └── producer/ │ │ │ │ ├── acl/ │ │ │ │ │ └── main.go │ │ │ │ ├── async/ │ │ │ │ │ └── main.go │ │ │ │ ├── batch/ │ │ │ │ │ └── main.go │ │ │ │ ├── delay/ │ │ │ │ │ └── main.go │ │ │ │ ├── interceptor/ │ │ │ │ │ └── main.go │ │ │ │ ├── namespace/ │ │ │ │ │ └── main.go │ │ │ │ ├── simple/ │ │ │ │ │ ├── main │ │ │ │ │ └── main.go │ │ │ │ ├── tag/ │ │ │ │ │ └── main.go │ │ │ │ ├── trace/ │ │ │ │ │ └── main.go │ │ │ │ └── transaction/ │ │ │ │ └── main.go │ │ │ ├── internal/ │ │ │ │ ├── callback.go │ │ │ │ ├── client.go │ │ │ │ ├── constants.go │ │ │ │ ├── mock_client.go │ │ │ │ ├── mock_namesrv.go │ │ │ │ ├── model.go │ │ │ │ ├── model_test.go │ │ │ │ ├── mq_version.go │ │ │ │ ├── namesrv.go │ │ │ │ ├── namesrv_test.go │ │ │ │ ├── perm.go │ │ │ │ ├── remote/ │ │ │ │ │ ├── codec.go │ │ │ │ │ ├── codec_test.go │ │ │ │ │ ├── future.go │ │ │ │ │ ├── interceptor.go │ │ │ │ │ ├── interceptor_test.go │ │ │ │ │ ├── mock_remote_client.go │ │ │ │ │ ├── remote_client.go │ │ │ │ │ ├── remote_client_test.go │ │ │ │ │ ├── rpchook.go │ │ │ │ │ └── tcp_conn.go │ │ │ │ ├── request.go │ │ │ │ ├── response.go │ │ │ │ ├── route.go │ │ │ │ ├── route_test.go │ │ │ │ ├── trace.go │ │ │ │ ├── trace_test.go │ │ │ │ ├── transaction.go │ │ │ │ ├── utils/ │ │ │ │ │ ├── errors.go │ │ │ │ │ ├── files.go │ │ │ │ │ ├── helper.go │ │ │ │ │ ├── helper_test.go │ │ │ │ │ ├── math.go │ │ │ │ │ ├── net.go │ │ │ │ │ ├── net_test.go │ │ │ │ │ ├── set.go │ │ │ │ │ └── string.go │ │ │ │ └── validators.go │ │ │ ├── primitive/ │ │ │ │ ├── auth.go │ │ │ │ ├── base.go │ │ │ │ ├── base_test.go │ │ │ │ ├── ctx.go │ │ │ │ ├── errors.go │ │ │ │ ├── interceptor.go │ │ │ │ ├── message.go │ │ │ │ ├── message_test.go │ │ │ │ ├── pool.go │ │ │ │ ├── result.go │ │ │ │ ├── result_test.go │ │ │ │ └── trace.go │ │ │ ├── producer/ │ │ │ │ ├── interceptor.go │ │ │ │ ├── option.go │ │ │ │ ├── producer.go │ │ │ │ ├── producer_test.go │ │ │ │ ├── selector.go │ │ │ │ └── selector_test.go │ │ │ ├── release-notes.md │ │ │ └── rlog/ │ │ │ └── log.go │ │ ├── aws/ │ │ │ └── aws-sdk-go/ │ │ │ ├── LICENSE.txt │ │ │ ├── NOTICE.txt │ │ │ ├── aws/ │ │ │ │ ├── awserr/ │ │ │ │ │ ├── error.go │ │ │ │ │ └── types.go │ │ │ │ ├── awsutil/ │ │ │ │ │ ├── copy.go │ │ │ │ │ ├── equal.go │ │ │ │ │ ├── path_value.go │ │ │ │ │ ├── prettify.go │ │ │ │ │ └── string_value.go │ │ │ │ ├── client/ │ │ │ │ │ ├── client.go │ │ │ │ │ ├── default_retryer.go │ │ │ │ │ ├── logger.go │ │ │ │ │ └── metadata/ │ │ │ │ │ └── client_info.go │ │ │ │ ├── config.go │ │ │ │ ├── context.go │ │ │ │ ├── context_1_6.go │ │ │ │ ├── context_1_7.go │ │ │ │ ├── convert_types.go │ │ │ │ ├── corehandlers/ │ │ │ │ │ ├── handlers.go │ │ │ │ │ ├── param_validator.go │ │ │ │ │ └── user_agent.go │ │ │ │ ├── credentials/ │ │ │ │ │ ├── chain_provider.go │ │ │ │ │ ├── credentials.go │ │ │ │ │ ├── ec2rolecreds/ │ │ │ │ │ │ └── ec2_role_provider.go │ │ │ │ │ ├── endpointcreds/ │ │ │ │ │ │ └── provider.go │ │ │ │ │ ├── env_provider.go │ │ │ │ │ ├── shared_credentials_provider.go │ │ │ │ │ ├── static_provider.go │ │ │ │ │ └── stscreds/ │ │ │ │ │ └── assume_role_provider.go │ │ │ │ ├── csm/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── enable.go │ │ │ │ │ ├── metric.go │ │ │ │ │ ├── metric_chan.go │ │ │ │ │ └── reporter.go │ │ │ │ ├── defaults/ │ │ │ │ │ ├── defaults.go │ │ │ │ │ └── shared_config.go │ │ │ │ ├── doc.go │ │ │ │ ├── ec2metadata/ │ │ │ │ │ ├── api.go │ │ │ │ │ └── service.go │ │ │ │ ├── endpoints/ │ │ │ │ │ ├── decode.go │ │ │ │ │ ├── defaults.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── endpoints.go │ │ │ │ │ ├── v3model.go │ │ │ │ │ └── v3model_codegen.go │ │ │ │ ├── errors.go │ │ │ │ ├── jsonvalue.go │ │ │ │ ├── logger.go │ │ │ │ ├── request/ │ │ │ │ │ ├── connection_reset_error.go │ │ │ │ │ ├── connection_reset_error_other.go │ │ │ │ │ ├── handlers.go │ │ │ │ │ ├── http_request.go │ │ │ │ │ ├── offset_reader.go │ │ │ │ │ ├── request.go │ │ │ │ │ ├── request_1_7.go │ │ │ │ │ ├── request_1_8.go │ │ │ │ │ ├── request_context.go │ │ │ │ │ ├── request_context_1_6.go │ │ │ │ │ ├── request_pagination.go │ │ │ │ │ ├── retryer.go │ │ │ │ │ ├── timeout_read_closer.go │ │ │ │ │ ├── validation.go │ │ │ │ │ └── waiter.go │ │ │ │ ├── session/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── env_config.go │ │ │ │ │ ├── session.go │ │ │ │ │ └── shared_config.go │ │ │ │ ├── signer/ │ │ │ │ │ └── v4/ │ │ │ │ │ ├── header_rules.go │ │ │ │ │ ├── options.go │ │ │ │ │ ├── uri_path.go │ │ │ │ │ └── v4.go │ │ │ │ ├── types.go │ │ │ │ ├── url.go │ │ │ │ ├── url_1_7.go │ │ │ │ └── version.go │ │ │ ├── internal/ │ │ │ │ ├── ini/ │ │ │ │ │ ├── ast.go │ │ │ │ │ ├── comma_token.go │ │ │ │ │ ├── comment_token.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── empty_token.go │ │ │ │ │ ├── expression.go │ │ │ │ │ ├── fuzz.go │ │ │ │ │ ├── ini.go │ │ │ │ │ ├── ini_lexer.go │ │ │ │ │ ├── ini_parser.go │ │ │ │ │ ├── literal_tokens.go │ │ │ │ │ ├── newline_token.go │ │ │ │ │ ├── number_helper.go │ │ │ │ │ ├── op_tokens.go │ │ │ │ │ ├── parse_error.go │ │ │ │ │ ├── parse_stack.go │ │ │ │ │ ├── sep_tokens.go │ │ │ │ │ ├── skipper.go │ │ │ │ │ ├── statement.go │ │ │ │ │ ├── value_util.go │ │ │ │ │ ├── visitor.go │ │ │ │ │ ├── walker.go │ │ │ │ │ └── ws_token.go │ │ │ │ ├── sdkio/ │ │ │ │ │ ├── io_go1.6.go │ │ │ │ │ └── io_go1.7.go │ │ │ │ ├── sdkrand/ │ │ │ │ │ └── locked_source.go │ │ │ │ ├── sdkuri/ │ │ │ │ │ └── path.go │ │ │ │ └── shareddefaults/ │ │ │ │ ├── ecs_container.go │ │ │ │ └── shared_config.go │ │ │ ├── private/ │ │ │ │ └── protocol/ │ │ │ │ ├── host.go │ │ │ │ ├── idempotency.go │ │ │ │ ├── jsonvalue.go │ │ │ │ ├── payload.go │ │ │ │ ├── query/ │ │ │ │ │ ├── build.go │ │ │ │ │ ├── queryutil/ │ │ │ │ │ │ └── queryutil.go │ │ │ │ │ ├── unmarshal.go │ │ │ │ │ └── unmarshal_error.go │ │ │ │ ├── rest/ │ │ │ │ │ ├── build.go │ │ │ │ │ ├── payload.go │ │ │ │ │ └── unmarshal.go │ │ │ │ ├── timestamp.go │ │ │ │ ├── unmarshal.go │ │ │ │ └── xml/ │ │ │ │ └── xmlutil/ │ │ │ │ ├── build.go │ │ │ │ ├── unmarshal.go │ │ │ │ └── xml_to_struct.go │ │ │ └── service/ │ │ │ ├── sqs/ │ │ │ │ ├── api.go │ │ │ │ ├── checksums.go │ │ │ │ ├── customizations.go │ │ │ │ ├── doc.go │ │ │ │ ├── errors.go │ │ │ │ └── service.go │ │ │ └── sts/ │ │ │ ├── api.go │ │ │ ├── customizations.go │ │ │ ├── doc.go │ │ │ ├── errors.go │ │ │ └── service.go │ │ ├── beorn7/ │ │ │ └── perks/ │ │ │ ├── LICENSE │ │ │ └── quantile/ │ │ │ └── stream.go │ │ ├── cenkalti/ │ │ │ └── backoff/ │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── backoff.go │ │ │ ├── backoff_test.go │ │ │ ├── context.go │ │ │ ├── context_test.go │ │ │ ├── example_test.go │ │ │ ├── exponential.go │ │ │ ├── exponential_test.go │ │ │ ├── go.mod │ │ │ ├── retry.go │ │ │ ├── retry_test.go │ │ │ ├── ticker.go │ │ │ ├── ticker_test.go │ │ │ ├── timer.go │ │ │ ├── tries.go │ │ │ └── tries_test.go │ │ ├── cloudevents/ │ │ │ └── sdk-go/ │ │ │ ├── LICENSE │ │ │ ├── alias.go │ │ │ └── pkg/ │ │ │ └── cloudevents/ │ │ │ ├── client/ │ │ │ │ ├── client.go │ │ │ │ ├── defaulters.go │ │ │ │ ├── doc.go │ │ │ │ ├── observability.go │ │ │ │ ├── options.go │ │ │ │ └── receiver.go │ │ │ ├── codec/ │ │ │ │ ├── doc.go │ │ │ │ ├── jsoncodec.go │ │ │ │ └── observability.go │ │ │ ├── content_type.go │ │ │ ├── context/ │ │ │ │ ├── context.go │ │ │ │ ├── doc.go │ │ │ │ └── logger.go │ │ │ ├── data_content_encoding.go │ │ │ ├── datacodec/ │ │ │ │ ├── codec.go │ │ │ │ ├── doc.go │ │ │ │ ├── json/ │ │ │ │ │ ├── data.go │ │ │ │ │ ├── doc.go │ │ │ │ │ └── observability.go │ │ │ │ ├── observability.go │ │ │ │ └── xml/ │ │ │ │ ├── data.go │ │ │ │ ├── doc.go │ │ │ │ └── observability.go │ │ │ ├── doc.go │ │ │ ├── event.go │ │ │ ├── event_data.go │ │ │ ├── event_interface.go │ │ │ ├── event_reader.go │ │ │ ├── event_response.go │ │ │ ├── event_writer.go │ │ │ ├── eventcontext.go │ │ │ ├── eventcontext_v01.go │ │ │ ├── eventcontext_v01_reader.go │ │ │ ├── eventcontext_v01_writer.go │ │ │ ├── eventcontext_v02.go │ │ │ ├── eventcontext_v02_reader.go │ │ │ ├── eventcontext_v02_writer.go │ │ │ ├── eventcontext_v03.go │ │ │ ├── eventcontext_v03_reader.go │ │ │ ├── eventcontext_v03_writer.go │ │ │ ├── extensions.go │ │ │ ├── observability/ │ │ │ │ ├── doc.go │ │ │ │ ├── keys.go │ │ │ │ └── observer.go │ │ │ ├── transport/ │ │ │ │ ├── codec.go │ │ │ │ ├── doc.go │ │ │ │ ├── http/ │ │ │ │ │ ├── codec.go │ │ │ │ │ ├── codec_v01.go │ │ │ │ │ ├── codec_v02.go │ │ │ │ │ ├── codec_v03.go │ │ │ │ │ ├── context.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── encoding.go │ │ │ │ │ ├── message.go │ │ │ │ │ ├── observability.go │ │ │ │ │ ├── options.go │ │ │ │ │ └── transport.go │ │ │ │ ├── message.go │ │ │ │ └── transport.go │ │ │ └── types/ │ │ │ ├── allocate.go │ │ │ ├── doc.go │ │ │ ├── timestamp.go │ │ │ └── urlref.go │ │ ├── davecgh/ │ │ │ └── go-spew/ │ │ │ ├── LICENSE │ │ │ └── spew/ │ │ │ ├── bypass.go │ │ │ ├── bypasssafe.go │ │ │ ├── common.go │ │ │ ├── config.go │ │ │ ├── doc.go │ │ │ ├── dump.go │ │ │ ├── format.go │ │ │ └── spew.go │ │ ├── eapache/ │ │ │ ├── go-resiliency/ │ │ │ │ ├── LICENSE │ │ │ │ └── breaker/ │ │ │ │ └── breaker.go │ │ │ ├── go-xerial-snappy/ │ │ │ │ ├── LICENSE │ │ │ │ ├── fuzz.go │ │ │ │ └── snappy.go │ │ │ └── queue/ │ │ │ ├── LICENSE │ │ │ └── queue.go │ │ ├── emicklei/ │ │ │ └── go-restful/ │ │ │ ├── LICENSE │ │ │ ├── compress.go │ │ │ ├── compressor_cache.go │ │ │ ├── compressor_pools.go │ │ │ ├── compressors.go │ │ │ ├── constants.go │ │ │ ├── container.go │ │ │ ├── cors_filter.go │ │ │ ├── curly.go │ │ │ ├── curly_route.go │ │ │ ├── doc.go │ │ │ ├── entity_accessors.go │ │ │ ├── filter.go │ │ │ ├── json.go │ │ │ ├── jsoniter.go │ │ │ ├── jsr311.go │ │ │ ├── log/ │ │ │ │ └── log.go │ │ │ ├── logger.go │ │ │ ├── mime.go │ │ │ ├── options_filter.go │ │ │ ├── parameter.go │ │ │ ├── path_expression.go │ │ │ ├── path_processor.go │ │ │ ├── request.go │ │ │ ├── response.go │ │ │ ├── route.go │ │ │ ├── route_builder.go │ │ │ ├── router.go │ │ │ ├── service_error.go │ │ │ ├── web_service.go │ │ │ └── web_service_container.go │ │ ├── emirpasic/ │ │ │ └── gods/ │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── containers/ │ │ │ │ ├── containers.go │ │ │ │ ├── containers_test.go │ │ │ │ ├── enumerable.go │ │ │ │ ├── iterator.go │ │ │ │ └── serialization.go │ │ │ ├── examples/ │ │ │ │ ├── README.md │ │ │ │ ├── arraylist/ │ │ │ │ │ └── arraylist.go │ │ │ │ ├── arraystack/ │ │ │ │ │ └── arraystack.go │ │ │ │ ├── avltree/ │ │ │ │ │ └── avltree.go │ │ │ │ ├── binaryheap/ │ │ │ │ │ └── binaryheap.go │ │ │ │ ├── btree/ │ │ │ │ │ └── btree.go │ │ │ │ ├── customcomparator/ │ │ │ │ │ └── customcomparator.go │ │ │ │ ├── doublylinkedlist/ │ │ │ │ │ └── doublylinkedlist.go │ │ │ │ ├── enumerablewithindex/ │ │ │ │ │ └── enumerablewithindex.go │ │ │ │ ├── enumerablewithkey/ │ │ │ │ │ └── enumerablewithkey.go │ │ │ │ ├── godsort/ │ │ │ │ │ └── godsort.go │ │ │ │ ├── hashbidimap/ │ │ │ │ │ └── hashbidimap.go │ │ │ │ ├── hashmap/ │ │ │ │ │ └── hashmap.go │ │ │ │ ├── hashset/ │ │ │ │ │ └── hashset.go │ │ │ │ ├── iteratorwithindex/ │ │ │ │ │ └── iteratorwithindex.go │ │ │ │ ├── iteratorwithkey/ │ │ │ │ │ └── iteratorwithkey.go │ │ │ │ ├── linkedhashmap/ │ │ │ │ │ └── linkedhashmap.go │ │ │ │ ├── linkedhashset/ │ │ │ │ │ └── linkedhashset.go │ │ │ │ ├── linkedliststack/ │ │ │ │ │ └── linkedliststack.go │ │ │ │ ├── redblacktree/ │ │ │ │ │ └── redblacktree.go │ │ │ │ ├── redblacktreeextended/ │ │ │ │ │ └── redblacktreeextended.go │ │ │ │ ├── serialization/ │ │ │ │ │ └── serialization.go │ │ │ │ ├── singlylinkedlist/ │ │ │ │ │ └── singlylinkedlist.go │ │ │ │ ├── treebidimap/ │ │ │ │ │ └── treebidimap.go │ │ │ │ ├── treemap/ │ │ │ │ │ └── treemap.go │ │ │ │ └── treeset/ │ │ │ │ └── treeset.go │ │ │ ├── lists/ │ │ │ │ ├── arraylist/ │ │ │ │ │ ├── arraylist.go │ │ │ │ │ ├── arraylist_test.go │ │ │ │ │ ├── enumerable.go │ │ │ │ │ ├── iterator.go │ │ │ │ │ └── serialization.go │ │ │ │ ├── doublylinkedlist/ │ │ │ │ │ ├── doublylinkedlist.go │ │ │ │ │ ├── doublylinkedlist_test.go │ │ │ │ │ ├── enumerable.go │ │ │ │ │ ├── iterator.go │ │ │ │ │ └── serialization.go │ │ │ │ ├── lists.go │ │ │ │ └── singlylinkedlist/ │ │ │ │ ├── enumerable.go │ │ │ │ ├── iterator.go │ │ │ │ ├── serialization.go │ │ │ │ ├── singlylinkedlist.go │ │ │ │ └── singlylinkedlist_test.go │ │ │ ├── maps/ │ │ │ │ ├── hashbidimap/ │ │ │ │ │ ├── hashbidimap.go │ │ │ │ │ ├── hashbidimap_test.go │ │ │ │ │ └── serialization.go │ │ │ │ ├── hashmap/ │ │ │ │ │ ├── hashmap.go │ │ │ │ │ ├── hashmap_test.go │ │ │ │ │ └── serialization.go │ │ │ │ ├── linkedhashmap/ │ │ │ │ │ ├── enumerable.go │ │ │ │ │ ├── iterator.go │ │ │ │ │ ├── linkedhashmap.go │ │ │ │ │ ├── linkedhashmap_test.go │ │ │ │ │ └── serialization.go │ │ │ │ ├── maps.go │ │ │ │ ├── treebidimap/ │ │ │ │ │ ├── enumerable.go │ │ │ │ │ ├── iterator.go │ │ │ │ │ ├── serialization.go │ │ │ │ │ ├── treebidimap.go │ │ │ │ │ └── treebidimap_test.go │ │ │ │ └── treemap/ │ │ │ │ ├── enumerable.go │ │ │ │ ├── iterator.go │ │ │ │ ├── serialization.go │ │ │ │ ├── treemap.go │ │ │ │ └── treemap_test.go │ │ │ ├── sets/ │ │ │ │ ├── hashset/ │ │ │ │ │ ├── hashset.go │ │ │ │ │ ├── hashset_test.go │ │ │ │ │ └── serialization.go │ │ │ │ ├── linkedhashset/ │ │ │ │ │ ├── enumerable.go │ │ │ │ │ ├── iterator.go │ │ │ │ │ ├── linkedhashset.go │ │ │ │ │ ├── linkedhashset_test.go │ │ │ │ │ └── serialization.go │ │ │ │ ├── sets.go │ │ │ │ └── treeset/ │ │ │ │ ├── enumerable.go │ │ │ │ ├── iterator.go │ │ │ │ ├── serialization.go │ │ │ │ ├── treeset.go │ │ │ │ └── treeset_test.go │ │ │ ├── stacks/ │ │ │ │ ├── arraystack/ │ │ │ │ │ ├── arraystack.go │ │ │ │ │ ├── arraystack_test.go │ │ │ │ │ ├── iterator.go │ │ │ │ │ └── serialization.go │ │ │ │ ├── linkedliststack/ │ │ │ │ │ ├── iterator.go │ │ │ │ │ ├── linkedliststack.go │ │ │ │ │ ├── linkedliststack_test.go │ │ │ │ │ └── serialization.go │ │ │ │ └── stacks.go │ │ │ ├── trees/ │ │ │ │ ├── avltree/ │ │ │ │ │ ├── avltree.go │ │ │ │ │ ├── avltree_test.go │ │ │ │ │ ├── iterator.go │ │ │ │ │ └── serialization.go │ │ │ │ ├── binaryheap/ │ │ │ │ │ ├── binaryheap.go │ │ │ │ │ ├── binaryheap_test.go │ │ │ │ │ ├── iterator.go │ │ │ │ │ └── serialization.go │ │ │ │ ├── btree/ │ │ │ │ │ ├── btree.go │ │ │ │ │ ├── btree_test.go │ │ │ │ │ ├── iterator.go │ │ │ │ │ └── serialization.go │ │ │ │ ├── redblacktree/ │ │ │ │ │ ├── iterator.go │ │ │ │ │ ├── redblacktree.go │ │ │ │ │ ├── redblacktree_test.go │ │ │ │ │ └── serialization.go │ │ │ │ └── trees.go │ │ │ └── utils/ │ │ │ ├── comparator.go │ │ │ ├── comparator_test.go │ │ │ ├── sort.go │ │ │ ├── sort_test.go │ │ │ ├── utils.go │ │ │ └── utils_test.go │ │ ├── evanphx/ │ │ │ └── json-patch/ │ │ │ ├── LICENSE │ │ │ ├── merge.go │ │ │ └── patch.go │ │ ├── ghodss/ │ │ │ └── yaml/ │ │ │ ├── LICENSE │ │ │ ├── fields.go │ │ │ └── yaml.go │ │ ├── go-logr/ │ │ │ ├── logr/ │ │ │ │ ├── LICENSE │ │ │ │ └── logr.go │ │ │ └── zapr/ │ │ │ ├── LICENSE │ │ │ └── zapr.go │ │ ├── gobuffalo/ │ │ │ └── envy/ │ │ │ ├── LICENSE.txt │ │ │ ├── envy.go │ │ │ └── version.go │ │ ├── gogap/ │ │ │ ├── errors/ │ │ │ │ ├── LICENSE │ │ │ │ ├── context.go │ │ │ │ ├── error_tmpl.go │ │ │ │ ├── errors.go │ │ │ │ └── errors_internal.go │ │ │ └── stack/ │ │ │ ├── license │ │ │ ├── patents │ │ │ └── stack.go │ │ ├── gogo/ │ │ │ └── protobuf/ │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── GOLANG_CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── proto/ │ │ │ │ ├── clone.go │ │ │ │ ├── custom_gogo.go │ │ │ │ ├── decode.go │ │ │ │ ├── discard.go │ │ │ │ ├── duration.go │ │ │ │ ├── duration_gogo.go │ │ │ │ ├── encode.go │ │ │ │ ├── encode_gogo.go │ │ │ │ ├── equal.go │ │ │ │ ├── extensions.go │ │ │ │ ├── extensions_gogo.go │ │ │ │ ├── lib.go │ │ │ │ ├── lib_gogo.go │ │ │ │ ├── message_set.go │ │ │ │ ├── pointer_reflect.go │ │ │ │ ├── pointer_reflect_gogo.go │ │ │ │ ├── pointer_unsafe.go │ │ │ │ ├── pointer_unsafe_gogo.go │ │ │ │ ├── properties.go │ │ │ │ ├── properties_gogo.go │ │ │ │ ├── skip_gogo.go │ │ │ │ ├── table_marshal.go │ │ │ │ ├── table_marshal_gogo.go │ │ │ │ ├── table_merge.go │ │ │ │ ├── table_unmarshal.go │ │ │ │ ├── table_unmarshal_gogo.go │ │ │ │ ├── text.go │ │ │ │ ├── text_gogo.go │ │ │ │ ├── text_parser.go │ │ │ │ ├── timestamp.go │ │ │ │ └── timestamp_gogo.go │ │ │ └── sortkeys/ │ │ │ └── sortkeys.go │ │ ├── golang/ │ │ │ ├── glog/ │ │ │ │ ├── LICENSE │ │ │ │ ├── glog.go │ │ │ │ └── glog_file.go │ │ │ ├── groupcache/ │ │ │ │ ├── LICENSE │ │ │ │ └── lru/ │ │ │ │ └── lru.go │ │ │ ├── mock/ │ │ │ │ └── gomock/ │ │ │ │ ├── call.go │ │ │ │ ├── call_test.go │ │ │ │ ├── callset.go │ │ │ │ ├── callset_test.go │ │ │ │ ├── controller.go │ │ │ │ ├── controller_test.go │ │ │ │ ├── internal/ │ │ │ │ │ └── mock_gomock/ │ │ │ │ │ └── mock_matcher.go │ │ │ │ ├── matchers.go │ │ │ │ └── matchers_test.go │ │ │ ├── protobuf/ │ │ │ │ ├── AUTHORS │ │ │ │ ├── CONTRIBUTORS │ │ │ │ ├── LICENSE │ │ │ │ ├── proto/ │ │ │ │ │ ├── clone.go │ │ │ │ │ ├── decode.go │ │ │ │ │ ├── discard.go │ │ │ │ │ ├── encode.go │ │ │ │ │ ├── equal.go │ │ │ │ │ ├── extensions.go │ │ │ │ │ ├── lib.go │ │ │ │ │ ├── message_set.go │ │ │ │ │ ├── pointer_reflect.go │ │ │ │ │ ├── pointer_unsafe.go │ │ │ │ │ ├── properties.go │ │ │ │ │ ├── table_marshal.go │ │ │ │ │ ├── table_merge.go │ │ │ │ │ ├── table_unmarshal.go │ │ │ │ │ ├── text.go │ │ │ │ │ └── text_parser.go │ │ │ │ ├── protoc-gen-go/ │ │ │ │ │ └── descriptor/ │ │ │ │ │ └── descriptor.pb.go │ │ │ │ └── ptypes/ │ │ │ │ ├── any/ │ │ │ │ │ └── any.pb.go │ │ │ │ ├── any.go │ │ │ │ ├── doc.go │ │ │ │ ├── duration/ │ │ │ │ │ └── duration.pb.go │ │ │ │ ├── duration.go │ │ │ │ ├── empty/ │ │ │ │ │ └── empty.pb.go │ │ │ │ ├── timestamp/ │ │ │ │ │ └── timestamp.pb.go │ │ │ │ └── timestamp.go │ │ │ └── snappy/ │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── decode.go │ │ │ ├── decode_amd64.go │ │ │ ├── decode_amd64.s │ │ │ ├── decode_other.go │ │ │ ├── encode.go │ │ │ ├── encode_amd64.go │ │ │ ├── encode_amd64.s │ │ │ ├── encode_other.go │ │ │ └── snappy.go │ │ ├── google/ │ │ │ ├── btree/ │ │ │ │ ├── LICENSE │ │ │ │ ├── btree.go │ │ │ │ └── btree_mem.go │ │ │ ├── go-cmp/ │ │ │ │ ├── LICENSE │ │ │ │ └── cmp/ │ │ │ │ ├── cmpopts/ │ │ │ │ │ ├── equate.go │ │ │ │ │ ├── ignore.go │ │ │ │ │ ├── sort.go │ │ │ │ │ ├── struct_filter.go │ │ │ │ │ └── xform.go │ │ │ │ ├── compare.go │ │ │ │ ├── export_panic.go │ │ │ │ ├── export_unsafe.go │ │ │ │ ├── internal/ │ │ │ │ │ ├── diff/ │ │ │ │ │ │ ├── debug_disable.go │ │ │ │ │ │ ├── debug_enable.go │ │ │ │ │ │ └── diff.go │ │ │ │ │ ├── flags/ │ │ │ │ │ │ ├── flags.go │ │ │ │ │ │ ├── toolchain_legacy.go │ │ │ │ │ │ └── toolchain_recent.go │ │ │ │ │ ├── function/ │ │ │ │ │ │ └── func.go │ │ │ │ │ └── value/ │ │ │ │ │ ├── pointer_purego.go │ │ │ │ │ ├── pointer_unsafe.go │ │ │ │ │ ├── sort.go │ │ │ │ │ └── zero.go │ │ │ │ ├── options.go │ │ │ │ ├── path.go │ │ │ │ ├── report.go │ │ │ │ ├── report_compare.go │ │ │ │ ├── report_reflect.go │ │ │ │ ├── report_slices.go │ │ │ │ ├── report_text.go │ │ │ │ └── report_value.go │ │ │ ├── go-containerregistry/ │ │ │ │ ├── LICENSE │ │ │ │ └── pkg/ │ │ │ │ └── name/ │ │ │ │ ├── check.go │ │ │ │ ├── digest.go │ │ │ │ ├── doc.go │ │ │ │ ├── errors.go │ │ │ │ ├── options.go │ │ │ │ ├── ref.go │ │ │ │ ├── registry.go │ │ │ │ ├── repository.go │ │ │ │ └── tag.go │ │ │ ├── go-github/ │ │ │ │ ├── AUTHORS │ │ │ │ ├── LICENSE │ │ │ │ └── github/ │ │ │ │ ├── activity.go │ │ │ │ ├── activity_events.go │ │ │ │ ├── activity_notifications.go │ │ │ │ ├── activity_star.go │ │ │ │ ├── activity_watching.go │ │ │ │ ├── admin.go │ │ │ │ ├── admin_stats.go │ │ │ │ ├── apps.go │ │ │ │ ├── apps_installation.go │ │ │ │ ├── apps_marketplace.go │ │ │ │ ├── authorizations.go │ │ │ │ ├── checks.go │ │ │ │ ├── doc.go │ │ │ │ ├── event_types.go │ │ │ │ ├── gen-accessors.go │ │ │ │ ├── gists.go │ │ │ │ ├── gists_comments.go │ │ │ │ ├── git.go │ │ │ │ ├── git_blobs.go │ │ │ │ ├── git_commits.go │ │ │ │ ├── git_refs.go │ │ │ │ ├── git_tags.go │ │ │ │ ├── git_trees.go │ │ │ │ ├── github-accessors.go │ │ │ │ ├── github.go │ │ │ │ ├── gitignore.go │ │ │ │ ├── issues.go │ │ │ │ ├── issues_assignees.go │ │ │ │ ├── issues_comments.go │ │ │ │ ├── issues_events.go │ │ │ │ ├── issues_labels.go │ │ │ │ ├── issues_milestones.go │ │ │ │ ├── issues_timeline.go │ │ │ │ ├── licenses.go │ │ │ │ ├── messages.go │ │ │ │ ├── migrations.go │ │ │ │ ├── migrations_source_import.go │ │ │ │ ├── migrations_user.go │ │ │ │ ├── misc.go │ │ │ │ ├── orgs.go │ │ │ │ ├── orgs_hooks.go │ │ │ │ ├── orgs_members.go │ │ │ │ ├── orgs_outside_collaborators.go │ │ │ │ ├── orgs_projects.go │ │ │ │ ├── orgs_users_blocking.go │ │ │ │ ├── projects.go │ │ │ │ ├── pulls.go │ │ │ │ ├── pulls_comments.go │ │ │ │ ├── pulls_reviewers.go │ │ │ │ ├── pulls_reviews.go │ │ │ │ ├── reactions.go │ │ │ │ ├── repos.go │ │ │ │ ├── repos_collaborators.go │ │ │ │ ├── repos_comments.go │ │ │ │ ├── repos_commits.go │ │ │ │ ├── repos_community_health.go │ │ │ │ ├── repos_contents.go │ │ │ │ ├── repos_deployments.go │ │ │ │ ├── repos_forks.go │ │ │ │ ├── repos_hooks.go │ │ │ │ ├── repos_invitations.go │ │ │ │ ├── repos_keys.go │ │ │ │ ├── repos_merging.go │ │ │ │ ├── repos_pages.go │ │ │ │ ├── repos_prereceive_hooks.go │ │ │ │ ├── repos_projects.go │ │ │ │ ├── repos_releases.go │ │ │ │ ├── repos_stats.go │ │ │ │ ├── repos_statuses.go │ │ │ │ ├── repos_traffic.go │ │ │ │ ├── search.go │ │ │ │ ├── strings.go │ │ │ │ ├── teams.go │ │ │ │ ├── teams_discussion_comments.go │ │ │ │ ├── teams_discussions.go │ │ │ │ ├── teams_members.go │ │ │ │ ├── timestamp.go │ │ │ │ ├── users.go │ │ │ │ ├── users_administration.go │ │ │ │ ├── users_blocking.go │ │ │ │ ├── users_emails.go │ │ │ │ ├── users_followers.go │ │ │ │ ├── users_gpg_keys.go │ │ │ │ ├── users_keys.go │ │ │ │ ├── with_appengine.go │ │ │ │ └── without_appengine.go │ │ │ ├── go-querystring/ │ │ │ │ ├── LICENSE │ │ │ │ └── query/ │ │ │ │ └── encode.go │ │ │ ├── gofuzz/ │ │ │ │ ├── LICENSE │ │ │ │ ├── doc.go │ │ │ │ └── fuzz.go │ │ │ ├── licenseclassifier/ │ │ │ │ ├── LICENSE │ │ │ │ ├── classifier.go │ │ │ │ ├── file_system_resources.go │ │ │ │ ├── forbidden.go │ │ │ │ ├── internal/ │ │ │ │ │ └── sets/ │ │ │ │ │ ├── sets.go │ │ │ │ │ └── stringset.go │ │ │ │ ├── license_type.go │ │ │ │ ├── licenses/ │ │ │ │ │ └── Unlicense.txt │ │ │ │ └── stringclassifier/ │ │ │ │ ├── LICENSE │ │ │ │ ├── classifier.go │ │ │ │ ├── internal/ │ │ │ │ │ └── pq/ │ │ │ │ │ └── priority.go │ │ │ │ └── searchset/ │ │ │ │ ├── searchset.go │ │ │ │ └── tokenizer/ │ │ │ │ └── tokenizer.go │ │ │ └── uuid/ │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── dce.go │ │ │ ├── doc.go │ │ │ ├── hash.go │ │ │ ├── marshal.go │ │ │ ├── node.go │ │ │ ├── node_js.go │ │ │ ├── node_net.go │ │ │ ├── sql.go │ │ │ ├── time.go │ │ │ ├── util.go │ │ │ ├── uuid.go │ │ │ ├── version1.go │ │ │ └── version4.go │ │ ├── googleapis/ │ │ │ ├── gax-go/ │ │ │ │ ├── LICENSE │ │ │ │ ├── call_option.go │ │ │ │ ├── gax.go │ │ │ │ ├── header.go │ │ │ │ └── invoke.go │ │ │ └── gnostic/ │ │ │ ├── LICENSE │ │ │ ├── OpenAPIv2/ │ │ │ │ ├── OpenAPIv2.go │ │ │ │ └── OpenAPIv2.pb.go │ │ │ ├── compiler/ │ │ │ │ ├── context.go │ │ │ │ ├── error.go │ │ │ │ ├── extension-handler.go │ │ │ │ ├── helpers.go │ │ │ │ ├── main.go │ │ │ │ └── reader.go │ │ │ └── extensions/ │ │ │ ├── extension.pb.go │ │ │ └── extensions.go │ │ ├── gorilla/ │ │ │ └── websocket/ │ │ │ ├── AUTHORS │ │ │ ├── LICENSE │ │ │ ├── client.go │ │ │ ├── client_clone.go │ │ │ ├── client_clone_legacy.go │ │ │ ├── compression.go │ │ │ ├── conn.go │ │ │ ├── conn_write.go │ │ │ ├── conn_write_legacy.go │ │ │ ├── doc.go │ │ │ ├── json.go │ │ │ ├── mask.go │ │ │ ├── mask_safe.go │ │ │ ├── prepared.go │ │ │ ├── proxy.go │ │ │ ├── server.go │ │ │ ├── trace.go │ │ │ ├── trace_17.go │ │ │ ├── util.go │ │ │ └── x_net_proxy.go │ │ ├── gregjones/ │ │ │ └── httpcache/ │ │ │ ├── LICENSE.txt │ │ │ ├── diskcache/ │ │ │ │ └── diskcache.go │ │ │ └── httpcache.go │ │ ├── hashicorp/ │ │ │ └── golang-lru/ │ │ │ ├── 2q.go │ │ │ ├── LICENSE │ │ │ ├── arc.go │ │ │ ├── doc.go │ │ │ ├── lru.go │ │ │ └── simplelru/ │ │ │ ├── lru.go │ │ │ └── lru_interface.go │ │ ├── hpcloud/ │ │ │ └── tail/ │ │ │ ├── LICENSE.txt │ │ │ ├── ratelimiter/ │ │ │ │ ├── Licence │ │ │ │ ├── leakybucket.go │ │ │ │ ├── memory.go │ │ │ │ └── storage.go │ │ │ ├── tail.go │ │ │ ├── tail_posix.go │ │ │ ├── tail_windows.go │ │ │ ├── util/ │ │ │ │ └── util.go │ │ │ ├── watch/ │ │ │ │ ├── filechanges.go │ │ │ │ ├── inotify.go │ │ │ │ ├── inotify_tracker.go │ │ │ │ ├── polling.go │ │ │ │ └── watch.go │ │ │ └── winfile/ │ │ │ └── winfile.go │ │ ├── imdario/ │ │ │ └── mergo/ │ │ │ ├── LICENSE │ │ │ ├── doc.go │ │ │ ├── map.go │ │ │ ├── merge.go │ │ │ ├── mergo.go │ │ │ └── testdata/ │ │ │ └── license.yml │ │ ├── inconshreveable/ │ │ │ └── mousetrap/ │ │ │ ├── LICENSE │ │ │ ├── trap_others.go │ │ │ ├── trap_windows.go │ │ │ └── trap_windows_1.4.go │ │ ├── jmespath/ │ │ │ └── go-jmespath/ │ │ │ ├── LICENSE │ │ │ ├── api.go │ │ │ ├── astnodetype_string.go │ │ │ ├── functions.go │ │ │ ├── interpreter.go │ │ │ ├── lexer.go │ │ │ ├── parser.go │ │ │ ├── toktype_string.go │ │ │ └── util.go │ │ ├── joho/ │ │ │ └── godotenv/ │ │ │ ├── LICENCE │ │ │ └── godotenv.go │ │ ├── json-iterator/ │ │ │ └── go/ │ │ │ ├── LICENSE │ │ │ ├── adapter.go │ │ │ ├── any.go │ │ │ ├── any_array.go │ │ │ ├── any_bool.go │ │ │ ├── any_float.go │ │ │ ├── any_int32.go │ │ │ ├── any_int64.go │ │ │ ├── any_invalid.go │ │ │ ├── any_nil.go │ │ │ ├── any_number.go │ │ │ ├── any_object.go │ │ │ ├── any_str.go │ │ │ ├── any_uint32.go │ │ │ ├── any_uint64.go │ │ │ ├── config.go │ │ │ ├── iter.go │ │ │ ├── iter_array.go │ │ │ ├── iter_float.go │ │ │ ├── iter_int.go │ │ │ ├── iter_object.go │ │ │ ├── iter_skip.go │ │ │ ├── iter_skip_sloppy.go │ │ │ ├── iter_skip_strict.go │ │ │ ├── iter_str.go │ │ │ ├── jsoniter.go │ │ │ ├── pool.go │ │ │ ├── reflect.go │ │ │ ├── reflect_array.go │ │ │ ├── reflect_dynamic.go │ │ │ ├── reflect_extension.go │ │ │ ├── reflect_json_number.go │ │ │ ├── reflect_json_raw_message.go │ │ │ ├── reflect_map.go │ │ │ ├── reflect_marshaler.go │ │ │ ├── reflect_native.go │ │ │ ├── reflect_optional.go │ │ │ ├── reflect_slice.go │ │ │ ├── reflect_struct_decoder.go │ │ │ ├── reflect_struct_encoder.go │ │ │ ├── stream.go │ │ │ ├── stream_float.go │ │ │ ├── stream_int.go │ │ │ └── stream_str.go │ │ ├── kelseyhightower/ │ │ │ └── envconfig/ │ │ │ ├── LICENSE │ │ │ ├── doc.go │ │ │ ├── env_os.go │ │ │ ├── env_syscall.go │ │ │ ├── envconfig.go │ │ │ └── usage.go │ │ ├── klauspost/ │ │ │ ├── compress/ │ │ │ │ ├── LICENSE │ │ │ │ ├── flate/ │ │ │ │ │ ├── copy.go │ │ │ │ │ ├── crc32_amd64.go │ │ │ │ │ ├── crc32_amd64.s │ │ │ │ │ ├── crc32_noasm.go │ │ │ │ │ ├── deflate.go │ │ │ │ │ ├── dict_decoder.go │ │ │ │ │ ├── gen.go │ │ │ │ │ ├── huffman_bit_writer.go │ │ │ │ │ ├── huffman_code.go │ │ │ │ │ ├── inflate.go │ │ │ │ │ ├── reverse_bits.go │ │ │ │ │ ├── snappy.go │ │ │ │ │ └── token.go │ │ │ │ ├── gzip/ │ │ │ │ │ ├── gunzip.go │ │ │ │ │ └── gzip.go │ │ │ │ ├── snappy/ │ │ │ │ │ ├── AUTHORS │ │ │ │ │ ├── CONTRIBUTORS │ │ │ │ │ └── LICENSE │ │ │ │ └── zlib/ │ │ │ │ ├── reader.go │ │ │ │ └── writer.go │ │ │ └── cpuid/ │ │ │ ├── LICENSE │ │ │ ├── cpuid.go │ │ │ ├── cpuid_386.s │ │ │ ├── cpuid_amd64.s │ │ │ ├── detect_intel.go │ │ │ ├── detect_ref.go │ │ │ ├── generate.go │ │ │ └── private-gen.go │ │ ├── knative/ │ │ │ ├── eventing/ │ │ │ │ ├── AUTHORS │ │ │ │ ├── LICENSE │ │ │ │ ├── pkg/ │ │ │ │ │ ├── apis/ │ │ │ │ │ │ ├── duck/ │ │ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ │ │ ├── channelable_types.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── subscribable_types.go │ │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ │ ├── eventing/ │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ │ │ ├── broker_defaults.go │ │ │ │ │ │ │ ├── broker_lifecycle.go │ │ │ │ │ │ │ ├── broker_types.go │ │ │ │ │ │ │ ├── broker_validation.go │ │ │ │ │ │ │ ├── channel_defaults.go │ │ │ │ │ │ │ ├── channel_lifecycle.go │ │ │ │ │ │ │ ├── channel_types.go │ │ │ │ │ │ │ ├── channel_validation.go │ │ │ │ │ │ │ ├── cluster_channel_provisioner_defaults.go │ │ │ │ │ │ │ ├── cluster_channel_provisioner_types.go │ │ │ │ │ │ │ ├── cluster_channel_provisioner_validation.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── eventtype_defaults.go │ │ │ │ │ │ │ ├── eventtype_lifecycle.go │ │ │ │ │ │ │ ├── eventtype_types.go │ │ │ │ │ │ │ ├── eventtype_validation.go │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ ├── subscribable_channelable_validation.go │ │ │ │ │ │ │ ├── subscription_defaults.go │ │ │ │ │ │ │ ├── subscription_lifecycle.go │ │ │ │ │ │ │ ├── subscription_types.go │ │ │ │ │ │ │ ├── subscription_validation.go │ │ │ │ │ │ │ ├── test_helper.go │ │ │ │ │ │ │ ├── trigger_defaults.go │ │ │ │ │ │ │ ├── trigger_lifecycle.go │ │ │ │ │ │ │ ├── trigger_types.go │ │ │ │ │ │ │ ├── trigger_validation.go │ │ │ │ │ │ │ ├── user_info.go │ │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ │ ├── messaging/ │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── in_memory_channel_defaults.go │ │ │ │ │ │ │ ├── in_memory_channel_lifecycle.go │ │ │ │ │ │ │ ├── in_memory_channel_types.go │ │ │ │ │ │ │ ├── in_memory_channel_validation.go │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ ├── sequence_defaults.go │ │ │ │ │ │ │ ├── sequence_lifecycle.go │ │ │ │ │ │ │ ├── sequence_types.go │ │ │ │ │ │ │ ├── sequence_validation.go │ │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ │ └── sources/ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ │ ├── apiserver_lifecycle.go │ │ │ │ │ │ ├── apiserver_types.go │ │ │ │ │ │ ├── containersource_lifecycle.go │ │ │ │ │ │ ├── containersource_types.go │ │ │ │ │ │ ├── cron_job_lifecycle.go │ │ │ │ │ │ ├── cron_job_types.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ └── client/ │ │ │ │ │ └── clientset/ │ │ │ │ │ └── versioned/ │ │ │ │ │ ├── clientset.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── scheme/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── register.go │ │ │ │ │ └── typed/ │ │ │ │ │ ├── eventing/ │ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ │ ├── broker.go │ │ │ │ │ │ ├── channel.go │ │ │ │ │ │ ├── clusterchannelprovisioner.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── eventing_client.go │ │ │ │ │ │ ├── eventtype.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ ├── subscription.go │ │ │ │ │ │ └── trigger.go │ │ │ │ │ ├── messaging/ │ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ ├── inmemorychannel.go │ │ │ │ │ │ ├── messaging_client.go │ │ │ │ │ │ └── sequence.go │ │ │ │ │ └── sources/ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ ├── apiserversource.go │ │ │ │ │ ├── containersource.go │ │ │ │ │ ├── cronjobsource.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ └── sources_client.go │ │ │ │ └── test/ │ │ │ │ └── test_images/ │ │ │ │ └── logevents/ │ │ │ │ └── kodata/ │ │ │ │ └── LICENSE │ │ │ ├── serving/ │ │ │ │ ├── AUTHORS │ │ │ │ ├── LICENSE │ │ │ │ ├── pkg/ │ │ │ │ │ ├── apis/ │ │ │ │ │ │ ├── autoscaling/ │ │ │ │ │ │ │ ├── annotation_validation.go │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── pa_defaults.go │ │ │ │ │ │ │ ├── pa_lifecycle.go │ │ │ │ │ │ │ ├── pa_types.go │ │ │ │ │ │ │ ├── pa_validation.go │ │ │ │ │ │ │ ├── podscalable_types.go │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ │ ├── config/ │ │ │ │ │ │ │ ├── defaults.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── store.go │ │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ │ ├── networking/ │ │ │ │ │ │ │ ├── generic_types.go │ │ │ │ │ │ │ ├── ports.go │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ │ │ ├── certificate_defaults.go │ │ │ │ │ │ │ ├── certificate_lifecycle.go │ │ │ │ │ │ │ ├── certificate_types.go │ │ │ │ │ │ │ ├── certificate_validation.go │ │ │ │ │ │ │ ├── clusteringress_defaults.go │ │ │ │ │ │ │ ├── clusteringress_lifecycle.go │ │ │ │ │ │ │ ├── clusteringress_types.go │ │ │ │ │ │ │ ├── clusteringress_validation.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── ingress_defaults.go │ │ │ │ │ │ │ ├── ingress_lifecycle.go │ │ │ │ │ │ │ ├── ingress_types.go │ │ │ │ │ │ │ ├── ingress_validation.go │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ ├── serverlessservice_defaults.go │ │ │ │ │ │ │ ├── serverlessservice_lifecycle.go │ │ │ │ │ │ │ ├── serverlessservice_types.go │ │ │ │ │ │ │ ├── serverlessservice_validation.go │ │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ │ └── serving/ │ │ │ │ │ │ ├── fieldmask.go │ │ │ │ │ │ ├── k8s_validation.go │ │ │ │ │ │ ├── metadata_validation.go │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ │ ├── configuration_conversion.go │ │ │ │ │ │ │ ├── configuration_defaults.go │ │ │ │ │ │ │ ├── configuration_lifecycle.go │ │ │ │ │ │ │ ├── configuration_types.go │ │ │ │ │ │ │ ├── configuration_validation.go │ │ │ │ │ │ │ ├── conversion_error.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ ├── revision_conversion.go │ │ │ │ │ │ │ ├── revision_defaults.go │ │ │ │ │ │ │ ├── revision_lifecycle.go │ │ │ │ │ │ │ ├── revision_types.go │ │ │ │ │ │ │ ├── revision_validation.go │ │ │ │ │ │ │ ├── route_conversion.go │ │ │ │ │ │ │ ├── route_defaults.go │ │ │ │ │ │ │ ├── route_lifecycle.go │ │ │ │ │ │ │ ├── route_types.go │ │ │ │ │ │ │ ├── route_validation.go │ │ │ │ │ │ │ ├── service_conversion.go │ │ │ │ │ │ │ ├── service_defaults.go │ │ │ │ │ │ │ ├── service_lifecycle.go │ │ │ │ │ │ │ ├── service_types.go │ │ │ │ │ │ │ ├── service_validation.go │ │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ │ └── v1beta1/ │ │ │ │ │ │ ├── configuration_conversion.go │ │ │ │ │ │ ├── configuration_defaults.go │ │ │ │ │ │ ├── configuration_lifecycle.go │ │ │ │ │ │ ├── configuration_types.go │ │ │ │ │ │ ├── configuration_validation.go │ │ │ │ │ │ ├── contexts.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ ├── revision_conversion.go │ │ │ │ │ │ ├── revision_defaults.go │ │ │ │ │ │ ├── revision_lifecycle.go │ │ │ │ │ │ ├── revision_types.go │ │ │ │ │ │ ├── revision_validation.go │ │ │ │ │ │ ├── route_conversion.go │ │ │ │ │ │ ├── route_defaults.go │ │ │ │ │ │ ├── route_lifecycle.go │ │ │ │ │ │ ├── route_types.go │ │ │ │ │ │ ├── route_validation.go │ │ │ │ │ │ ├── service_conversion.go │ │ │ │ │ │ ├── service_defaults.go │ │ │ │ │ │ ├── service_lifecycle.go │ │ │ │ │ │ ├── service_types.go │ │ │ │ │ │ ├── service_validation.go │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ └── client/ │ │ │ │ │ └── clientset/ │ │ │ │ │ └── versioned/ │ │ │ │ │ ├── clientset.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── scheme/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── register.go │ │ │ │ │ └── typed/ │ │ │ │ │ ├── autoscaling/ │ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ │ ├── autoscaling_client.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ └── podautoscaler.go │ │ │ │ │ ├── networking/ │ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ │ ├── certificate.go │ │ │ │ │ │ ├── clusteringress.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ ├── ingress.go │ │ │ │ │ │ ├── networking_client.go │ │ │ │ │ │ └── serverlessservice.go │ │ │ │ │ └── serving/ │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ ├── configuration.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ ├── revision.go │ │ │ │ │ │ ├── route.go │ │ │ │ │ │ ├── service.go │ │ │ │ │ │ └── serving_client.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── configuration.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── revision.go │ │ │ │ │ ├── route.go │ │ │ │ │ ├── service.go │ │ │ │ │ └── serving_client.go │ │ │ │ └── third_party/ │ │ │ │ └── config/ │ │ │ │ └── monitoring/ │ │ │ │ ├── logging/ │ │ │ │ │ └── elasticsearch/ │ │ │ │ │ └── LICENSE │ │ │ │ └── metrics/ │ │ │ │ └── prometheus/ │ │ │ │ ├── kubernetes/ │ │ │ │ │ └── LICENSE │ │ │ │ └── prometheus-operator/ │ │ │ │ ├── LICENSE │ │ │ │ └── NOTICE │ │ │ └── test-infra/ │ │ │ ├── LICENSE │ │ │ ├── scripts/ │ │ │ │ ├── README.md │ │ │ │ ├── dummy.go │ │ │ │ ├── e2e-tests.sh │ │ │ │ ├── library.sh │ │ │ │ ├── markdown-link-check-config.rc │ │ │ │ ├── markdown-lint-config.rc │ │ │ │ ├── presubmit-tests.sh │ │ │ │ └── release.sh │ │ │ └── tools/ │ │ │ └── dep-collector/ │ │ │ ├── README.md │ │ │ ├── imports.go │ │ │ ├── licenses.go │ │ │ └── main.go │ │ ├── markbates/ │ │ │ └── inflect/ │ │ │ ├── LICENCE │ │ │ ├── helpers.go │ │ │ ├── inflect.go │ │ │ ├── name.go │ │ │ └── version.go │ │ ├── mattbaird/ │ │ │ └── jsonpatch/ │ │ │ ├── LICENSE │ │ │ └── jsonpatch.go │ │ ├── matttproud/ │ │ │ └── golang_protobuf_extensions/ │ │ │ ├── LICENSE │ │ │ ├── NOTICE │ │ │ └── pbutil/ │ │ │ ├── decode.go │ │ │ ├── doc.go │ │ │ └── encode.go │ │ ├── modern-go/ │ │ │ ├── concurrent/ │ │ │ │ ├── LICENSE │ │ │ │ ├── executor.go │ │ │ │ ├── go_above_19.go │ │ │ │ ├── go_below_19.go │ │ │ │ ├── log.go │ │ │ │ └── unbounded_executor.go │ │ │ └── reflect2/ │ │ │ ├── LICENSE │ │ │ ├── go_above_17.go │ │ │ ├── go_above_19.go │ │ │ ├── go_below_17.go │ │ │ ├── go_below_19.go │ │ │ ├── reflect2.go │ │ │ ├── reflect2_amd64.s │ │ │ ├── reflect2_kind.go │ │ │ ├── relfect2_386.s │ │ │ ├── relfect2_amd64p32.s │ │ │ ├── relfect2_arm.s │ │ │ ├── relfect2_arm64.s │ │ │ ├── relfect2_mips64x.s │ │ │ ├── relfect2_mipsx.s │ │ │ ├── relfect2_ppc64x.s │ │ │ ├── relfect2_s390x.s │ │ │ ├── safe_field.go │ │ │ ├── safe_map.go │ │ │ ├── safe_slice.go │ │ │ ├── safe_struct.go │ │ │ ├── safe_type.go │ │ │ ├── type_map.go │ │ │ ├── unsafe_array.go │ │ │ ├── unsafe_eface.go │ │ │ ├── unsafe_field.go │ │ │ ├── unsafe_iface.go │ │ │ ├── unsafe_link.go │ │ │ ├── unsafe_map.go │ │ │ ├── unsafe_ptr.go │ │ │ ├── unsafe_slice.go │ │ │ ├── unsafe_struct.go │ │ │ └── unsafe_type.go │ │ ├── onsi/ │ │ │ ├── ginkgo/ │ │ │ │ ├── LICENSE │ │ │ │ ├── config/ │ │ │ │ │ └── config.go │ │ │ │ ├── ginkgo_dsl.go │ │ │ │ ├── internal/ │ │ │ │ │ ├── codelocation/ │ │ │ │ │ │ └── code_location.go │ │ │ │ │ ├── containernode/ │ │ │ │ │ │ └── container_node.go │ │ │ │ │ ├── failer/ │ │ │ │ │ │ └── failer.go │ │ │ │ │ ├── leafnodes/ │ │ │ │ │ │ ├── benchmarker.go │ │ │ │ │ │ ├── interfaces.go │ │ │ │ │ │ ├── it_node.go │ │ │ │ │ │ ├── measure_node.go │ │ │ │ │ │ ├── runner.go │ │ │ │ │ │ ├── setup_nodes.go │ │ │ │ │ │ ├── suite_nodes.go │ │ │ │ │ │ ├── synchronized_after_suite_node.go │ │ │ │ │ │ └── synchronized_before_suite_node.go │ │ │ │ │ ├── remote/ │ │ │ │ │ │ ├── aggregator.go │ │ │ │ │ │ ├── forwarding_reporter.go │ │ │ │ │ │ ├── output_interceptor.go │ │ │ │ │ │ ├── output_interceptor_unix.go │ │ │ │ │ │ ├── output_interceptor_win.go │ │ │ │ │ │ ├── server.go │ │ │ │ │ │ ├── syscall_dup_linux_arm64.go │ │ │ │ │ │ ├── syscall_dup_solaris.go │ │ │ │ │ │ └── syscall_dup_unix.go │ │ │ │ │ ├── spec/ │ │ │ │ │ │ ├── spec.go │ │ │ │ │ │ └── specs.go │ │ │ │ │ ├── spec_iterator/ │ │ │ │ │ │ ├── index_computer.go │ │ │ │ │ │ ├── parallel_spec_iterator.go │ │ │ │ │ │ ├── serial_spec_iterator.go │ │ │ │ │ │ ├── sharded_parallel_spec_iterator.go │ │ │ │ │ │ └── spec_iterator.go │ │ │ │ │ ├── specrunner/ │ │ │ │ │ │ ├── random_id.go │ │ │ │ │ │ └── spec_runner.go │ │ │ │ │ ├── suite/ │ │ │ │ │ │ └── suite.go │ │ │ │ │ ├── testingtproxy/ │ │ │ │ │ │ └── testing_t_proxy.go │ │ │ │ │ └── writer/ │ │ │ │ │ ├── fake_writer.go │ │ │ │ │ └── writer.go │ │ │ │ ├── reporters/ │ │ │ │ │ ├── default_reporter.go │ │ │ │ │ ├── fake_reporter.go │ │ │ │ │ ├── junit_reporter.go │ │ │ │ │ ├── reporter.go │ │ │ │ │ ├── stenographer/ │ │ │ │ │ │ ├── console_logging.go │ │ │ │ │ │ ├── fake_stenographer.go │ │ │ │ │ │ ├── stenographer.go │ │ │ │ │ │ └── support/ │ │ │ │ │ │ ├── go-colorable/ │ │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ │ ├── colorable_others.go │ │ │ │ │ │ │ ├── colorable_windows.go │ │ │ │ │ │ │ └── noncolorable.go │ │ │ │ │ │ └── go-isatty/ │ │ │ │ │ │ ├── LICENSE │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── isatty_appengine.go │ │ │ │ │ │ ├── isatty_bsd.go │ │ │ │ │ │ ├── isatty_linux.go │ │ │ │ │ │ ├── isatty_solaris.go │ │ │ │ │ │ └── isatty_windows.go │ │ │ │ │ └── teamcity_reporter.go │ │ │ │ └── types/ │ │ │ │ ├── code_location.go │ │ │ │ ├── synchronization.go │ │ │ │ └── types.go │ │ │ └── gomega/ │ │ │ ├── LICENSE │ │ │ ├── format/ │ │ │ │ └── format.go │ │ │ ├── gbytes/ │ │ │ │ ├── buffer.go │ │ │ │ ├── io_wrappers.go │ │ │ │ └── say_matcher.go │ │ │ ├── gexec/ │ │ │ │ ├── build.go │ │ │ │ ├── exit_matcher.go │ │ │ │ ├── prefixed_writer.go │ │ │ │ └── session.go │ │ │ ├── gomega_dsl.go │ │ │ ├── internal/ │ │ │ │ ├── assertion/ │ │ │ │ │ └── assertion.go │ │ │ │ ├── asyncassertion/ │ │ │ │ │ └── async_assertion.go │ │ │ │ ├── oraclematcher/ │ │ │ │ │ └── oracle_matcher.go │ │ │ │ └── testingtsupport/ │ │ │ │ └── testing_t_support.go │ │ │ ├── matchers/ │ │ │ │ ├── and.go │ │ │ │ ├── assignable_to_type_of_matcher.go │ │ │ │ ├── attributes_slice.go │ │ │ │ ├── be_a_directory.go │ │ │ │ ├── be_a_regular_file.go │ │ │ │ ├── be_an_existing_file.go │ │ │ │ ├── be_closed_matcher.go │ │ │ │ ├── be_empty_matcher.go │ │ │ │ ├── be_equivalent_to_matcher.go │ │ │ │ ├── be_false_matcher.go │ │ │ │ ├── be_identical_to.go │ │ │ │ ├── be_nil_matcher.go │ │ │ │ ├── be_numerically_matcher.go │ │ │ │ ├── be_sent_matcher.go │ │ │ │ ├── be_temporally_matcher.go │ │ │ │ ├── be_true_matcher.go │ │ │ │ ├── be_zero_matcher.go │ │ │ │ ├── consist_of.go │ │ │ │ ├── contain_element_matcher.go │ │ │ │ ├── contain_substring_matcher.go │ │ │ │ ├── equal_matcher.go │ │ │ │ ├── have_cap_matcher.go │ │ │ │ ├── have_key_matcher.go │ │ │ │ ├── have_key_with_value_matcher.go │ │ │ │ ├── have_len_matcher.go │ │ │ │ ├── have_occurred_matcher.go │ │ │ │ ├── have_prefix_matcher.go │ │ │ │ ├── have_suffix_matcher.go │ │ │ │ ├── match_error_matcher.go │ │ │ │ ├── match_json_matcher.go │ │ │ │ ├── match_regexp_matcher.go │ │ │ │ ├── match_xml_matcher.go │ │ │ │ ├── match_yaml_matcher.go │ │ │ │ ├── not.go │ │ │ │ ├── or.go │ │ │ │ ├── panic_matcher.go │ │ │ │ ├── receive_matcher.go │ │ │ │ ├── semi_structured_data_support.go │ │ │ │ ├── succeed_matcher.go │ │ │ │ ├── support/ │ │ │ │ │ └── goraph/ │ │ │ │ │ ├── bipartitegraph/ │ │ │ │ │ │ ├── bipartitegraph.go │ │ │ │ │ │ └── bipartitegraphmatching.go │ │ │ │ │ ├── edge/ │ │ │ │ │ │ └── edge.go │ │ │ │ │ ├── node/ │ │ │ │ │ │ └── node.go │ │ │ │ │ └── util/ │ │ │ │ │ └── util.go │ │ │ │ ├── type_support.go │ │ │ │ └── with_transform.go │ │ │ ├── matchers.go │ │ │ └── types/ │ │ │ └── types.go │ │ ├── pborman/ │ │ │ └── uuid/ │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── dce.go │ │ │ ├── doc.go │ │ │ ├── hash.go │ │ │ ├── marshal.go │ │ │ ├── node.go │ │ │ ├── sql.go │ │ │ ├── time.go │ │ │ ├── util.go │ │ │ ├── uuid.go │ │ │ ├── version1.go │ │ │ └── version4.go │ │ ├── petar/ │ │ │ └── GoLLRB/ │ │ │ ├── AUTHORS │ │ │ ├── LICENSE │ │ │ └── llrb/ │ │ │ ├── avgvar.go │ │ │ ├── iterator.go │ │ │ ├── llrb-stats.go │ │ │ ├── llrb.go │ │ │ └── util.go │ │ ├── peterbourgon/ │ │ │ └── diskv/ │ │ │ ├── LICENSE │ │ │ ├── compression.go │ │ │ ├── diskv.go │ │ │ └── index.go │ │ ├── pierrec/ │ │ │ └── lz4/ │ │ │ ├── LICENSE │ │ │ ├── block.go │ │ │ ├── debug.go │ │ │ ├── debug_stub.go │ │ │ ├── decode_amd64.go │ │ │ ├── decode_amd64.s │ │ │ ├── decode_other.go │ │ │ ├── internal/ │ │ │ │ └── xxh32/ │ │ │ │ └── xxh32zero.go │ │ │ ├── lz4.go │ │ │ ├── lz4_go1.10.go │ │ │ ├── lz4_notgo1.10.go │ │ │ ├── reader.go │ │ │ └── writer.go │ │ ├── pkg/ │ │ │ └── errors/ │ │ │ ├── LICENSE │ │ │ ├── errors.go │ │ │ └── stack.go │ │ ├── prometheus/ │ │ │ ├── client_golang/ │ │ │ │ ├── LICENSE │ │ │ │ ├── NOTICE │ │ │ │ └── prometheus/ │ │ │ │ ├── collector.go │ │ │ │ ├── counter.go │ │ │ │ ├── desc.go │ │ │ │ ├── doc.go │ │ │ │ ├── expvar_collector.go │ │ │ │ ├── fnv.go │ │ │ │ ├── gauge.go │ │ │ │ ├── go_collector.go │ │ │ │ ├── histogram.go │ │ │ │ ├── http.go │ │ │ │ ├── internal/ │ │ │ │ │ └── metric.go │ │ │ │ ├── labels.go │ │ │ │ ├── metric.go │ │ │ │ ├── observer.go │ │ │ │ ├── process_collector.go │ │ │ │ ├── promhttp/ │ │ │ │ │ ├── delegator.go │ │ │ │ │ ├── delegator_1_8.go │ │ │ │ │ ├── delegator_pre_1_8.go │ │ │ │ │ ├── http.go │ │ │ │ │ ├── instrument_client.go │ │ │ │ │ ├── instrument_client_1_8.go │ │ │ │ │ └── instrument_server.go │ │ │ │ ├── registry.go │ │ │ │ ├── summary.go │ │ │ │ ├── timer.go │ │ │ │ ├── untyped.go │ │ │ │ ├── value.go │ │ │ │ ├── vec.go │ │ │ │ └── wrap.go │ │ │ ├── client_model/ │ │ │ │ ├── LICENSE │ │ │ │ ├── NOTICE │ │ │ │ ├── go/ │ │ │ │ │ └── metrics.pb.go │ │ │ │ └── ruby/ │ │ │ │ └── LICENSE │ │ │ ├── common/ │ │ │ │ ├── LICENSE │ │ │ │ ├── NOTICE │ │ │ │ ├── expfmt/ │ │ │ │ │ ├── decode.go │ │ │ │ │ ├── encode.go │ │ │ │ │ ├── expfmt.go │ │ │ │ │ ├── fuzz.go │ │ │ │ │ ├── text_create.go │ │ │ │ │ └── text_parse.go │ │ │ │ ├── internal/ │ │ │ │ │ └── bitbucket.org/ │ │ │ │ │ └── ww/ │ │ │ │ │ └── goautoneg/ │ │ │ │ │ └── autoneg.go │ │ │ │ └── model/ │ │ │ │ ├── alert.go │ │ │ │ ├── fingerprinting.go │ │ │ │ ├── fnv.go │ │ │ │ ├── labels.go │ │ │ │ ├── labelset.go │ │ │ │ ├── metric.go │ │ │ │ ├── model.go │ │ │ │ ├── signature.go │ │ │ │ ├── silence.go │ │ │ │ ├── time.go │ │ │ │ └── value.go │ │ │ └── procfs/ │ │ │ ├── LICENSE │ │ │ ├── NOTICE │ │ │ ├── buddyinfo.go │ │ │ ├── doc.go │ │ │ ├── fs.go │ │ │ ├── internal/ │ │ │ │ └── util/ │ │ │ │ ├── parse.go │ │ │ │ └── sysreadfile_linux.go │ │ │ ├── ipvs.go │ │ │ ├── mdstat.go │ │ │ ├── mountstats.go │ │ │ ├── net_dev.go │ │ │ ├── nfs/ │ │ │ │ ├── nfs.go │ │ │ │ ├── parse.go │ │ │ │ ├── parse_nfs.go │ │ │ │ └── parse_nfsd.go │ │ │ ├── proc.go │ │ │ ├── proc_io.go │ │ │ ├── proc_limits.go │ │ │ ├── proc_ns.go │ │ │ ├── proc_stat.go │ │ │ ├── stat.go │ │ │ ├── xfrm.go │ │ │ └── xfs/ │ │ │ ├── parse.go │ │ │ └── xfs.go │ │ ├── rcrowley/ │ │ │ └── go-metrics/ │ │ │ ├── LICENSE │ │ │ ├── counter.go │ │ │ ├── debug.go │ │ │ ├── ewma.go │ │ │ ├── gauge.go │ │ │ ├── gauge_float64.go │ │ │ ├── graphite.go │ │ │ ├── healthcheck.go │ │ │ ├── histogram.go │ │ │ ├── json.go │ │ │ ├── log.go │ │ │ ├── meter.go │ │ │ ├── metrics.go │ │ │ ├── opentsdb.go │ │ │ ├── registry.go │ │ │ ├── runtime.go │ │ │ ├── runtime_cgo.go │ │ │ ├── runtime_gccpufraction.go │ │ │ ├── runtime_no_cgo.go │ │ │ ├── runtime_no_gccpufraction.go │ │ │ ├── sample.go │ │ │ ├── syslog.go │ │ │ ├── timer.go │ │ │ └── writer.go │ │ ├── satori/ │ │ │ └── go.uuid/ │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── codec.go │ │ │ ├── codec_test.go │ │ │ ├── generator.go │ │ │ ├── generator_test.go │ │ │ ├── sql.go │ │ │ ├── sql_test.go │ │ │ ├── uuid.go │ │ │ └── uuid_test.go │ │ ├── sergi/ │ │ │ └── go-diff/ │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ └── diffmatchpatch/ │ │ │ ├── diff.go │ │ │ ├── diffmatchpatch.go │ │ │ ├── match.go │ │ │ ├── mathutil.go │ │ │ ├── patch.go │ │ │ └── stringutil.go │ │ ├── sirupsen/ │ │ │ └── logrus/ │ │ │ ├── .golangci.yml │ │ │ ├── .travis.yml │ │ │ ├── CHANGELOG.md │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── alt_exit.go │ │ │ ├── alt_exit_test.go │ │ │ ├── appveyor.yml │ │ │ ├── doc.go │ │ │ ├── entry.go │ │ │ ├── entry_test.go │ │ │ ├── example_basic_test.go │ │ │ ├── example_custom_caller_test.go │ │ │ ├── example_default_field_value_test.go │ │ │ ├── example_global_hook_test.go │ │ │ ├── example_hook_test.go │ │ │ ├── exported.go │ │ │ ├── formatter.go │ │ │ ├── formatter_bench_test.go │ │ │ ├── go.mod │ │ │ ├── go.sum │ │ │ ├── hook_test.go │ │ │ ├── hooks/ │ │ │ │ ├── syslog/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── syslog.go │ │ │ │ │ └── syslog_test.go │ │ │ │ └── test/ │ │ │ │ ├── test.go │ │ │ │ └── test_test.go │ │ │ ├── hooks.go │ │ │ ├── internal/ │ │ │ │ └── testutils/ │ │ │ │ └── testutils.go │ │ │ ├── json_formatter.go │ │ │ ├── json_formatter_test.go │ │ │ ├── level_test.go │ │ │ ├── logger.go │ │ │ ├── logger_bench_test.go │ │ │ ├── logger_test.go │ │ │ ├── logrus.go │ │ │ ├── logrus_test.go │ │ │ ├── terminal_check_appengine.go │ │ │ ├── terminal_check_bsd.go │ │ │ ├── terminal_check_js.go │ │ │ ├── terminal_check_no_terminal.go │ │ │ ├── terminal_check_notappengine.go │ │ │ ├── terminal_check_solaris.go │ │ │ ├── terminal_check_unix.go │ │ │ ├── terminal_check_windows.go │ │ │ ├── text_formatter.go │ │ │ ├── text_formatter_test.go │ │ │ ├── travis/ │ │ │ │ ├── cross_build.sh │ │ │ │ ├── install.sh │ │ │ │ └── lint.sh │ │ │ ├── writer.go │ │ │ └── writer_test.go │ │ ├── souriki/ │ │ │ └── ali_mns/ │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── client.go │ │ │ ├── credential.go │ │ │ ├── decoder.go │ │ │ ├── errors.go │ │ │ ├── example/ │ │ │ │ ├── app.conf.example │ │ │ │ ├── queue_example.go │ │ │ │ └── topic_example.go │ │ │ ├── message.go │ │ │ ├── qps_monitor.go │ │ │ ├── queue.go │ │ │ ├── queue_manager.go │ │ │ ├── topic.go │ │ │ ├── topic_manager.go │ │ │ └── utils.go │ │ ├── spf13/ │ │ │ ├── afero/ │ │ │ │ ├── LICENSE.txt │ │ │ │ ├── afero.go │ │ │ │ ├── basepath.go │ │ │ │ ├── cacheOnReadFs.go │ │ │ │ ├── const_bsds.go │ │ │ │ ├── const_win_unix.go │ │ │ │ ├── copyOnWriteFs.go │ │ │ │ ├── httpFs.go │ │ │ │ ├── ioutil.go │ │ │ │ ├── lstater.go │ │ │ │ ├── match.go │ │ │ │ ├── mem/ │ │ │ │ │ ├── dir.go │ │ │ │ │ ├── dirmap.go │ │ │ │ │ └── file.go │ │ │ │ ├── memmap.go │ │ │ │ ├── os.go │ │ │ │ ├── path.go │ │ │ │ ├── readonlyfs.go │ │ │ │ ├── regexpfs.go │ │ │ │ ├── unionFile.go │ │ │ │ └── util.go │ │ │ ├── cobra/ │ │ │ │ ├── LICENSE.txt │ │ │ │ ├── args.go │ │ │ │ ├── bash_completions.go │ │ │ │ ├── cobra/ │ │ │ │ │ └── cmd/ │ │ │ │ │ └── testdata/ │ │ │ │ │ └── LICENSE.golden │ │ │ │ ├── cobra.go │ │ │ │ ├── command.go │ │ │ │ ├── command_notwin.go │ │ │ │ ├── command_win.go │ │ │ │ └── zsh_completions.go │ │ │ └── pflag/ │ │ │ ├── LICENSE │ │ │ ├── bool.go │ │ │ ├── bool_slice.go │ │ │ ├── bytes.go │ │ │ ├── count.go │ │ │ ├── duration.go │ │ │ ├── duration_slice.go │ │ │ ├── flag.go │ │ │ ├── float32.go │ │ │ ├── float64.go │ │ │ ├── golangflag.go │ │ │ ├── int.go │ │ │ ├── int16.go │ │ │ ├── int32.go │ │ │ ├── int64.go │ │ │ ├── int8.go │ │ │ ├── int_slice.go │ │ │ ├── ip.go │ │ │ ├── ip_slice.go │ │ │ ├── ipmask.go │ │ │ ├── ipnet.go │ │ │ ├── string.go │ │ │ ├── string_array.go │ │ │ ├── string_slice.go │ │ │ ├── string_to_int.go │ │ │ ├── string_to_string.go │ │ │ ├── uint.go │ │ │ ├── uint16.go │ │ │ ├── uint32.go │ │ │ ├── uint64.go │ │ │ ├── uint8.go │ │ │ └── uint_slice.go │ │ ├── tidwall/ │ │ │ ├── gjson/ │ │ │ │ ├── .travis.yml │ │ │ │ ├── LICENSE │ │ │ │ ├── README.md │ │ │ │ ├── SYNTAX.md │ │ │ │ ├── gjson.go │ │ │ │ ├── gjson_gae.go │ │ │ │ ├── gjson_ngae.go │ │ │ │ ├── gjson_test.go │ │ │ │ ├── go.mod │ │ │ │ └── go.sum │ │ │ ├── match/ │ │ │ │ ├── .travis.yml │ │ │ │ ├── LICENSE │ │ │ │ ├── README.md │ │ │ │ ├── match.go │ │ │ │ └── match_test.go │ │ │ └── pretty/ │ │ │ ├── .travis.yml │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── pretty.go │ │ │ └── pretty_test.go │ │ └── valyala/ │ │ ├── bytebufferpool/ │ │ │ ├── LICENSE │ │ │ ├── bytebuffer.go │ │ │ ├── doc.go │ │ │ └── pool.go │ │ └── fasthttp/ │ │ ├── LICENSE │ │ ├── args.go │ │ ├── bytebuffer.go │ │ ├── bytesconv.go │ │ ├── bytesconv_32.go │ │ ├── bytesconv_64.go │ │ ├── client.go │ │ ├── coarseTime.go │ │ ├── compress.go │ │ ├── cookie.go │ │ ├── doc.go │ │ ├── fasthttputil/ │ │ │ ├── doc.go │ │ │ ├── inmemory_listener.go │ │ │ └── pipeconns.go │ │ ├── fs.go │ │ ├── header.go │ │ ├── http.go │ │ ├── lbclient.go │ │ ├── nocopy.go │ │ ├── peripconn.go │ │ ├── reuseport/ │ │ │ └── LICENSE │ │ ├── server.go │ │ ├── stackless/ │ │ │ ├── doc.go │ │ │ ├── func.go │ │ │ └── writer.go │ │ ├── status.go │ │ ├── stream.go │ │ ├── strings.go │ │ ├── tcpdialer.go │ │ ├── timer.go │ │ ├── uri.go │ │ ├── uri_unix.go │ │ ├── uri_windows.go │ │ ├── userdata.go │ │ └── workerpool.go │ ├── go.opencensus.io/ │ │ ├── AUTHORS │ │ ├── LICENSE │ │ ├── exemplar/ │ │ │ └── exemplar.go │ │ ├── internal/ │ │ │ ├── internal.go │ │ │ ├── sanitize.go │ │ │ ├── tagencoding/ │ │ │ │ └── tagencoding.go │ │ │ └── traceinternals.go │ │ ├── opencensus.go │ │ ├── plugin/ │ │ │ ├── ocgrpc/ │ │ │ │ ├── client.go │ │ │ │ ├── client_metrics.go │ │ │ │ ├── client_stats_handler.go │ │ │ │ ├── doc.go │ │ │ │ ├── server.go │ │ │ │ ├── server_metrics.go │ │ │ │ ├── server_stats_handler.go │ │ │ │ ├── stats_common.go │ │ │ │ └── trace_common.go │ │ │ └── ochttp/ │ │ │ ├── client.go │ │ │ ├── client_stats.go │ │ │ ├── doc.go │ │ │ ├── propagation/ │ │ │ │ └── b3/ │ │ │ │ └── b3.go │ │ │ ├── route.go │ │ │ ├── server.go │ │ │ ├── span_annotating_client_trace.go │ │ │ ├── stats.go │ │ │ └── trace.go │ │ ├── stats/ │ │ │ ├── doc.go │ │ │ ├── internal/ │ │ │ │ ├── record.go │ │ │ │ └── validation.go │ │ │ ├── measure.go │ │ │ ├── measure_float64.go │ │ │ ├── measure_int64.go │ │ │ ├── record.go │ │ │ ├── units.go │ │ │ └── view/ │ │ │ ├── aggregation.go │ │ │ ├── aggregation_data.go │ │ │ ├── collector.go │ │ │ ├── doc.go │ │ │ ├── export.go │ │ │ ├── view.go │ │ │ ├── worker.go │ │ │ └── worker_commands.go │ │ ├── tag/ │ │ │ ├── context.go │ │ │ ├── doc.go │ │ │ ├── key.go │ │ │ ├── map.go │ │ │ ├── map_codec.go │ │ │ ├── profile_19.go │ │ │ ├── profile_not19.go │ │ │ └── validate.go │ │ └── trace/ │ │ ├── basetypes.go │ │ ├── config.go │ │ ├── doc.go │ │ ├── exemplar.go │ │ ├── export.go │ │ ├── internal/ │ │ │ └── internal.go │ │ ├── propagation/ │ │ │ └── propagation.go │ │ ├── sampling.go │ │ ├── spanbucket.go │ │ ├── spanstore.go │ │ ├── status_codes.go │ │ ├── trace.go │ │ ├── trace_go11.go │ │ ├── trace_nongo11.go │ │ └── tracestate/ │ │ └── tracestate.go │ ├── go.uber.org/ │ │ ├── atomic/ │ │ │ ├── LICENSE.txt │ │ │ ├── atomic.go │ │ │ └── string.go │ │ ├── multierr/ │ │ │ ├── LICENSE.txt │ │ │ └── error.go │ │ └── zap/ │ │ ├── LICENSE.txt │ │ ├── array.go │ │ ├── buffer/ │ │ │ ├── buffer.go │ │ │ └── pool.go │ │ ├── config.go │ │ ├── doc.go │ │ ├── encoder.go │ │ ├── error.go │ │ ├── field.go │ │ ├── flag.go │ │ ├── global.go │ │ ├── http_handler.go │ │ ├── internal/ │ │ │ ├── bufferpool/ │ │ │ │ └── bufferpool.go │ │ │ ├── color/ │ │ │ │ └── color.go │ │ │ └── exit/ │ │ │ └── exit.go │ │ ├── level.go │ │ ├── logger.go │ │ ├── options.go │ │ ├── sink.go │ │ ├── stacktrace.go │ │ ├── sugar.go │ │ ├── time.go │ │ ├── writer.go │ │ └── zapcore/ │ │ ├── console_encoder.go │ │ ├── core.go │ │ ├── doc.go │ │ ├── encoder.go │ │ ├── entry.go │ │ ├── error.go │ │ ├── field.go │ │ ├── hook.go │ │ ├── json_encoder.go │ │ ├── level.go │ │ ├── level_strings.go │ │ ├── marshaler.go │ │ ├── memory_encoder.go │ │ ├── sampler.go │ │ ├── tee.go │ │ └── write_syncer.go │ ├── golang.org/ │ │ └── x/ │ │ ├── crypto/ │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── PATENTS │ │ │ └── ssh/ │ │ │ └── terminal/ │ │ │ ├── terminal.go │ │ │ ├── util.go │ │ │ ├── util_bsd.go │ │ │ ├── util_linux.go │ │ │ ├── util_plan9.go │ │ │ ├── util_solaris.go │ │ │ └── util_windows.go │ │ ├── net/ │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── PATENTS │ │ │ ├── context/ │ │ │ │ ├── context.go │ │ │ │ ├── ctxhttp/ │ │ │ │ │ ├── ctxhttp.go │ │ │ │ │ └── ctxhttp_pre17.go │ │ │ │ ├── go17.go │ │ │ │ ├── go19.go │ │ │ │ ├── pre_go17.go │ │ │ │ └── pre_go19.go │ │ │ ├── html/ │ │ │ │ ├── atom/ │ │ │ │ │ ├── atom.go │ │ │ │ │ ├── gen.go │ │ │ │ │ └── table.go │ │ │ │ ├── charset/ │ │ │ │ │ └── charset.go │ │ │ │ ├── const.go │ │ │ │ ├── doc.go │ │ │ │ ├── doctype.go │ │ │ │ ├── entity.go │ │ │ │ ├── escape.go │ │ │ │ ├── foreign.go │ │ │ │ ├── node.go │ │ │ │ ├── parse.go │ │ │ │ ├── render.go │ │ │ │ └── token.go │ │ │ ├── http/ │ │ │ │ └── httpguts/ │ │ │ │ ├── guts.go │ │ │ │ └── httplex.go │ │ │ ├── http2/ │ │ │ │ ├── ciphers.go │ │ │ │ ├── client_conn_pool.go │ │ │ │ ├── configure_transport.go │ │ │ │ ├── databuffer.go │ │ │ │ ├── errors.go │ │ │ │ ├── flow.go │ │ │ │ ├── frame.go │ │ │ │ ├── go111.go │ │ │ │ ├── go16.go │ │ │ │ ├── go17.go │ │ │ │ ├── go17_not18.go │ │ │ │ ├── go18.go │ │ │ │ ├── go19.go │ │ │ │ ├── gotrack.go │ │ │ │ ├── headermap.go │ │ │ │ ├── hpack/ │ │ │ │ │ ├── encode.go │ │ │ │ │ ├── hpack.go │ │ │ │ │ ├── huffman.go │ │ │ │ │ └── tables.go │ │ │ │ ├── http2.go │ │ │ │ ├── not_go111.go │ │ │ │ ├── not_go16.go │ │ │ │ ├── not_go17.go │ │ │ │ ├── not_go18.go │ │ │ │ ├── not_go19.go │ │ │ │ ├── pipe.go │ │ │ │ ├── server.go │ │ │ │ ├── transport.go │ │ │ │ ├── write.go │ │ │ │ ├── writesched.go │ │ │ │ ├── writesched_priority.go │ │ │ │ └── writesched_random.go │ │ │ ├── idna/ │ │ │ │ ├── idna.go │ │ │ │ ├── punycode.go │ │ │ │ ├── tables.go │ │ │ │ ├── trie.go │ │ │ │ └── trieval.go │ │ │ ├── internal/ │ │ │ │ └── timeseries/ │ │ │ │ └── timeseries.go │ │ │ └── trace/ │ │ │ ├── events.go │ │ │ ├── histogram.go │ │ │ ├── trace.go │ │ │ ├── trace_go16.go │ │ │ └── trace_go17.go │ │ ├── oauth2/ │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── google/ │ │ │ │ ├── appengine.go │ │ │ │ ├── appengine_hook.go │ │ │ │ ├── appengineflex_hook.go │ │ │ │ ├── default.go │ │ │ │ ├── doc_go19.go │ │ │ │ ├── doc_not_go19.go │ │ │ │ ├── go19.go │ │ │ │ ├── google.go │ │ │ │ ├── jwt.go │ │ │ │ ├── not_go19.go │ │ │ │ └── sdk.go │ │ │ ├── internal/ │ │ │ │ ├── client_appengine.go │ │ │ │ ├── doc.go │ │ │ │ ├── oauth2.go │ │ │ │ ├── token.go │ │ │ │ └── transport.go │ │ │ ├── jws/ │ │ │ │ └── jws.go │ │ │ ├── jwt/ │ │ │ │ └── jwt.go │ │ │ ├── oauth2.go │ │ │ ├── token.go │ │ │ └── transport.go │ │ ├── sync/ │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── PATENTS │ │ │ ├── errgroup/ │ │ │ │ └── errgroup.go │ │ │ └── semaphore/ │ │ │ └── semaphore.go │ │ ├── sys/ │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── PATENTS │ │ │ ├── unix/ │ │ │ │ ├── affinity_linux.go │ │ │ │ ├── aliases.go │ │ │ │ ├── asm_aix_ppc64.s │ │ │ │ ├── asm_darwin_386.s │ │ │ │ ├── asm_darwin_amd64.s │ │ │ │ ├── asm_darwin_arm.s │ │ │ │ ├── asm_darwin_arm64.s │ │ │ │ ├── asm_dragonfly_amd64.s │ │ │ │ ├── asm_freebsd_386.s │ │ │ │ ├── asm_freebsd_amd64.s │ │ │ │ ├── asm_freebsd_arm.s │ │ │ │ ├── asm_linux_386.s │ │ │ │ ├── asm_linux_amd64.s │ │ │ │ ├── asm_linux_arm.s │ │ │ │ ├── asm_linux_arm64.s │ │ │ │ ├── asm_linux_mips64x.s │ │ │ │ ├── asm_linux_mipsx.s │ │ │ │ ├── asm_linux_ppc64x.s │ │ │ │ ├── asm_linux_s390x.s │ │ │ │ ├── asm_netbsd_386.s │ │ │ │ ├── asm_netbsd_amd64.s │ │ │ │ ├── asm_netbsd_arm.s │ │ │ │ ├── asm_openbsd_386.s │ │ │ │ ├── asm_openbsd_amd64.s │ │ │ │ ├── asm_openbsd_arm.s │ │ │ │ ├── asm_solaris_amd64.s │ │ │ │ ├── bluetooth_linux.go │ │ │ │ ├── cap_freebsd.go │ │ │ │ ├── constants.go │ │ │ │ ├── dev_aix_ppc.go │ │ │ │ ├── dev_aix_ppc64.go │ │ │ │ ├── dev_darwin.go │ │ │ │ ├── dev_dragonfly.go │ │ │ │ ├── dev_freebsd.go │ │ │ │ ├── dev_linux.go │ │ │ │ ├── dev_netbsd.go │ │ │ │ ├── dev_openbsd.go │ │ │ │ ├── dirent.go │ │ │ │ ├── endian_big.go │ │ │ │ ├── endian_little.go │ │ │ │ ├── env_unix.go │ │ │ │ ├── errors_freebsd_386.go │ │ │ │ ├── errors_freebsd_amd64.go │ │ │ │ ├── errors_freebsd_arm.go │ │ │ │ ├── fcntl.go │ │ │ │ ├── fcntl_linux_32bit.go │ │ │ │ ├── gccgo.go │ │ │ │ ├── gccgo_c.c │ │ │ │ ├── gccgo_linux_amd64.go │ │ │ │ ├── ioctl.go │ │ │ │ ├── mkpost.go │ │ │ │ ├── openbsd_pledge.go │ │ │ │ ├── pagesize_unix.go │ │ │ │ ├── race.go │ │ │ │ ├── race0.go │ │ │ │ ├── sockcmsg_linux.go │ │ │ │ ├── sockcmsg_unix.go │ │ │ │ ├── str.go │ │ │ │ ├── syscall.go │ │ │ │ ├── syscall_aix.go │ │ │ │ ├── syscall_aix_ppc.go │ │ │ │ ├── syscall_aix_ppc64.go │ │ │ │ ├── syscall_bsd.go │ │ │ │ ├── syscall_darwin.go │ │ │ │ ├── syscall_darwin_386.go │ │ │ │ ├── syscall_darwin_amd64.go │ │ │ │ ├── syscall_darwin_arm.go │ │ │ │ ├── syscall_darwin_arm64.go │ │ │ │ ├── syscall_dragonfly.go │ │ │ │ ├── syscall_dragonfly_amd64.go │ │ │ │ ├── syscall_freebsd.go │ │ │ │ ├── syscall_freebsd_386.go │ │ │ │ ├── syscall_freebsd_amd64.go │ │ │ │ ├── syscall_freebsd_arm.go │ │ │ │ ├── syscall_linux.go │ │ │ │ ├── syscall_linux_386.go │ │ │ │ ├── syscall_linux_amd64.go │ │ │ │ ├── syscall_linux_amd64_gc.go │ │ │ │ ├── syscall_linux_arm.go │ │ │ │ ├── syscall_linux_arm64.go │ │ │ │ ├── syscall_linux_gc.go │ │ │ │ ├── syscall_linux_gc_386.go │ │ │ │ ├── syscall_linux_gccgo_386.go │ │ │ │ ├── syscall_linux_gccgo_arm.go │ │ │ │ ├── syscall_linux_mips64x.go │ │ │ │ ├── syscall_linux_mipsx.go │ │ │ │ ├── syscall_linux_ppc64x.go │ │ │ │ ├── syscall_linux_riscv64.go │ │ │ │ ├── syscall_linux_s390x.go │ │ │ │ ├── syscall_linux_sparc64.go │ │ │ │ ├── syscall_netbsd.go │ │ │ │ ├── syscall_netbsd_386.go │ │ │ │ ├── syscall_netbsd_amd64.go │ │ │ │ ├── syscall_netbsd_arm.go │ │ │ │ ├── syscall_openbsd.go │ │ │ │ ├── syscall_openbsd_386.go │ │ │ │ ├── syscall_openbsd_amd64.go │ │ │ │ ├── syscall_openbsd_arm.go │ │ │ │ ├── syscall_solaris.go │ │ │ │ ├── syscall_solaris_amd64.go │ │ │ │ ├── syscall_unix.go │ │ │ │ ├── syscall_unix_gc.go │ │ │ │ ├── timestruct.go │ │ │ │ ├── types_aix.go │ │ │ │ ├── types_darwin.go │ │ │ │ ├── types_dragonfly.go │ │ │ │ ├── types_freebsd.go │ │ │ │ ├── types_netbsd.go │ │ │ │ ├── types_openbsd.go │ │ │ │ ├── types_solaris.go │ │ │ │ ├── xattr_bsd.go │ │ │ │ ├── zerrors_aix_ppc.go │ │ │ │ ├── zerrors_aix_ppc64.go │ │ │ │ ├── zerrors_darwin_386.go │ │ │ │ ├── zerrors_darwin_amd64.go │ │ │ │ ├── zerrors_darwin_arm.go │ │ │ │ ├── zerrors_darwin_arm64.go │ │ │ │ ├── zerrors_dragonfly_amd64.go │ │ │ │ ├── zerrors_freebsd_386.go │ │ │ │ ├── zerrors_freebsd_amd64.go │ │ │ │ ├── zerrors_freebsd_arm.go │ │ │ │ ├── zerrors_linux_386.go │ │ │ │ ├── zerrors_linux_amd64.go │ │ │ │ ├── zerrors_linux_arm.go │ │ │ │ ├── zerrors_linux_arm64.go │ │ │ │ ├── zerrors_linux_mips.go │ │ │ │ ├── zerrors_linux_mips64.go │ │ │ │ ├── zerrors_linux_mips64le.go │ │ │ │ ├── zerrors_linux_mipsle.go │ │ │ │ ├── zerrors_linux_ppc64.go │ │ │ │ ├── zerrors_linux_ppc64le.go │ │ │ │ ├── zerrors_linux_riscv64.go │ │ │ │ ├── zerrors_linux_s390x.go │ │ │ │ ├── zerrors_linux_sparc64.go │ │ │ │ ├── zerrors_netbsd_386.go │ │ │ │ ├── zerrors_netbsd_amd64.go │ │ │ │ ├── zerrors_netbsd_arm.go │ │ │ │ ├── zerrors_openbsd_386.go │ │ │ │ ├── zerrors_openbsd_amd64.go │ │ │ │ ├── zerrors_openbsd_arm.go │ │ │ │ ├── zerrors_solaris_amd64.go │ │ │ │ ├── zptrace386_linux.go │ │ │ │ ├── zptracearm_linux.go │ │ │ │ ├── zptracemips_linux.go │ │ │ │ ├── zptracemipsle_linux.go │ │ │ │ ├── zsyscall_aix_ppc.go │ │ │ │ ├── zsyscall_aix_ppc64.go │ │ │ │ ├── zsyscall_aix_ppc64_gc.go │ │ │ │ ├── zsyscall_aix_ppc64_gccgo.go │ │ │ │ ├── zsyscall_darwin_386.go │ │ │ │ ├── zsyscall_darwin_amd64.go │ │ │ │ ├── zsyscall_darwin_arm.go │ │ │ │ ├── zsyscall_darwin_arm64.go │ │ │ │ ├── zsyscall_dragonfly_amd64.go │ │ │ │ ├── zsyscall_freebsd_386.go │ │ │ │ ├── zsyscall_freebsd_amd64.go │ │ │ │ ├── zsyscall_freebsd_arm.go │ │ │ │ ├── zsyscall_linux_386.go │ │ │ │ ├── zsyscall_linux_amd64.go │ │ │ │ ├── zsyscall_linux_arm.go │ │ │ │ ├── zsyscall_linux_arm64.go │ │ │ │ ├── zsyscall_linux_mips.go │ │ │ │ ├── zsyscall_linux_mips64.go │ │ │ │ ├── zsyscall_linux_mips64le.go │ │ │ │ ├── zsyscall_linux_mipsle.go │ │ │ │ ├── zsyscall_linux_ppc64.go │ │ │ │ ├── zsyscall_linux_ppc64le.go │ │ │ │ ├── zsyscall_linux_riscv64.go │ │ │ │ ├── zsyscall_linux_s390x.go │ │ │ │ ├── zsyscall_linux_sparc64.go │ │ │ │ ├── zsyscall_netbsd_386.go │ │ │ │ ├── zsyscall_netbsd_amd64.go │ │ │ │ ├── zsyscall_netbsd_arm.go │ │ │ │ ├── zsyscall_openbsd_386.go │ │ │ │ ├── zsyscall_openbsd_amd64.go │ │ │ │ ├── zsyscall_openbsd_arm.go │ │ │ │ ├── zsyscall_solaris_amd64.go │ │ │ │ ├── zsysctl_openbsd_386.go │ │ │ │ ├── zsysctl_openbsd_amd64.go │ │ │ │ ├── zsysctl_openbsd_arm.go │ │ │ │ ├── zsysnum_darwin_386.go │ │ │ │ ├── zsysnum_darwin_amd64.go │ │ │ │ ├── zsysnum_darwin_arm.go │ │ │ │ ├── zsysnum_darwin_arm64.go │ │ │ │ ├── zsysnum_dragonfly_amd64.go │ │ │ │ ├── zsysnum_freebsd_386.go │ │ │ │ ├── zsysnum_freebsd_amd64.go │ │ │ │ ├── zsysnum_freebsd_arm.go │ │ │ │ ├── zsysnum_linux_386.go │ │ │ │ ├── zsysnum_linux_amd64.go │ │ │ │ ├── zsysnum_linux_arm.go │ │ │ │ ├── zsysnum_linux_arm64.go │ │ │ │ ├── zsysnum_linux_mips.go │ │ │ │ ├── zsysnum_linux_mips64.go │ │ │ │ ├── zsysnum_linux_mips64le.go │ │ │ │ ├── zsysnum_linux_mipsle.go │ │ │ │ ├── zsysnum_linux_ppc64.go │ │ │ │ ├── zsysnum_linux_ppc64le.go │ │ │ │ ├── zsysnum_linux_riscv64.go │ │ │ │ ├── zsysnum_linux_s390x.go │ │ │ │ ├── zsysnum_linux_sparc64.go │ │ │ │ ├── zsysnum_netbsd_386.go │ │ │ │ ├── zsysnum_netbsd_amd64.go │ │ │ │ ├── zsysnum_netbsd_arm.go │ │ │ │ ├── zsysnum_openbsd_386.go │ │ │ │ ├── zsysnum_openbsd_amd64.go │ │ │ │ ├── zsysnum_openbsd_arm.go │ │ │ │ ├── ztypes_aix_ppc.go │ │ │ │ ├── ztypes_aix_ppc64.go │ │ │ │ ├── ztypes_darwin_386.go │ │ │ │ ├── ztypes_darwin_amd64.go │ │ │ │ ├── ztypes_darwin_arm.go │ │ │ │ ├── ztypes_darwin_arm64.go │ │ │ │ ├── ztypes_dragonfly_amd64.go │ │ │ │ ├── ztypes_freebsd_386.go │ │ │ │ ├── ztypes_freebsd_amd64.go │ │ │ │ ├── ztypes_freebsd_arm.go │ │ │ │ ├── ztypes_linux_386.go │ │ │ │ ├── ztypes_linux_amd64.go │ │ │ │ ├── ztypes_linux_arm.go │ │ │ │ ├── ztypes_linux_arm64.go │ │ │ │ ├── ztypes_linux_mips.go │ │ │ │ ├── ztypes_linux_mips64.go │ │ │ │ ├── ztypes_linux_mips64le.go │ │ │ │ ├── ztypes_linux_mipsle.go │ │ │ │ ├── ztypes_linux_ppc64.go │ │ │ │ ├── ztypes_linux_ppc64le.go │ │ │ │ ├── ztypes_linux_riscv64.go │ │ │ │ ├── ztypes_linux_s390x.go │ │ │ │ ├── ztypes_linux_sparc64.go │ │ │ │ ├── ztypes_netbsd_386.go │ │ │ │ ├── ztypes_netbsd_amd64.go │ │ │ │ ├── ztypes_netbsd_arm.go │ │ │ │ ├── ztypes_openbsd_386.go │ │ │ │ ├── ztypes_openbsd_amd64.go │ │ │ │ ├── ztypes_openbsd_arm.go │ │ │ │ └── ztypes_solaris_amd64.go │ │ │ └── windows/ │ │ │ ├── aliases.go │ │ │ ├── asm_windows_386.s │ │ │ ├── asm_windows_amd64.s │ │ │ ├── asm_windows_arm.s │ │ │ ├── dll_windows.go │ │ │ ├── env_windows.go │ │ │ ├── eventlog.go │ │ │ ├── exec_windows.go │ │ │ ├── memory_windows.go │ │ │ ├── mksyscall.go │ │ │ ├── race.go │ │ │ ├── race0.go │ │ │ ├── security_windows.go │ │ │ ├── service.go │ │ │ ├── str.go │ │ │ ├── syscall.go │ │ │ ├── syscall_windows.go │ │ │ ├── types_windows.go │ │ │ ├── types_windows_386.go │ │ │ ├── types_windows_amd64.go │ │ │ ├── types_windows_arm.go │ │ │ └── zsyscall_windows.go │ │ ├── text/ │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── PATENTS │ │ │ ├── collate/ │ │ │ │ ├── build/ │ │ │ │ │ ├── builder.go │ │ │ │ │ ├── colelem.go │ │ │ │ │ ├── contract.go │ │ │ │ │ ├── order.go │ │ │ │ │ ├── table.go │ │ │ │ │ └── trie.go │ │ │ │ ├── collate.go │ │ │ │ ├── index.go │ │ │ │ ├── maketables.go │ │ │ │ ├── option.go │ │ │ │ ├── sort.go │ │ │ │ └── tables.go │ │ │ ├── encoding/ │ │ │ │ ├── charmap/ │ │ │ │ │ ├── charmap.go │ │ │ │ │ ├── maketables.go │ │ │ │ │ └── tables.go │ │ │ │ ├── encoding.go │ │ │ │ ├── htmlindex/ │ │ │ │ │ ├── gen.go │ │ │ │ │ ├── htmlindex.go │ │ │ │ │ ├── map.go │ │ │ │ │ └── tables.go │ │ │ │ ├── internal/ │ │ │ │ │ ├── identifier/ │ │ │ │ │ │ ├── gen.go │ │ │ │ │ │ ├── identifier.go │ │ │ │ │ │ └── mib.go │ │ │ │ │ └── internal.go │ │ │ │ ├── japanese/ │ │ │ │ │ ├── all.go │ │ │ │ │ ├── eucjp.go │ │ │ │ │ ├── iso2022jp.go │ │ │ │ │ ├── maketables.go │ │ │ │ │ ├── shiftjis.go │ │ │ │ │ └── tables.go │ │ │ │ ├── korean/ │ │ │ │ │ ├── euckr.go │ │ │ │ │ ├── maketables.go │ │ │ │ │ └── tables.go │ │ │ │ ├── simplifiedchinese/ │ │ │ │ │ ├── all.go │ │ │ │ │ ├── gbk.go │ │ │ │ │ ├── hzgb2312.go │ │ │ │ │ ├── maketables.go │ │ │ │ │ └── tables.go │ │ │ │ ├── traditionalchinese/ │ │ │ │ │ ├── big5.go │ │ │ │ │ ├── maketables.go │ │ │ │ │ └── tables.go │ │ │ │ └── unicode/ │ │ │ │ ├── override.go │ │ │ │ └── unicode.go │ │ │ ├── internal/ │ │ │ │ ├── colltab/ │ │ │ │ │ ├── collelem.go │ │ │ │ │ ├── colltab.go │ │ │ │ │ ├── contract.go │ │ │ │ │ ├── iter.go │ │ │ │ │ ├── numeric.go │ │ │ │ │ ├── table.go │ │ │ │ │ ├── trie.go │ │ │ │ │ └── weighter.go │ │ │ │ ├── gen/ │ │ │ │ │ ├── code.go │ │ │ │ │ └── gen.go │ │ │ │ ├── tag/ │ │ │ │ │ └── tag.go │ │ │ │ ├── triegen/ │ │ │ │ │ ├── compact.go │ │ │ │ │ ├── print.go │ │ │ │ │ └── triegen.go │ │ │ │ ├── ucd/ │ │ │ │ │ └── ucd.go │ │ │ │ └── utf8internal/ │ │ │ │ └── utf8internal.go │ │ │ ├── language/ │ │ │ │ ├── common.go │ │ │ │ ├── coverage.go │ │ │ │ ├── doc.go │ │ │ │ ├── gen.go │ │ │ │ ├── gen_common.go │ │ │ │ ├── gen_index.go │ │ │ │ ├── go1_1.go │ │ │ │ ├── go1_2.go │ │ │ │ ├── index.go │ │ │ │ ├── language.go │ │ │ │ ├── lookup.go │ │ │ │ ├── match.go │ │ │ │ ├── parse.go │ │ │ │ ├── tables.go │ │ │ │ └── tags.go │ │ │ ├── runes/ │ │ │ │ ├── cond.go │ │ │ │ └── runes.go │ │ │ ├── secure/ │ │ │ │ └── bidirule/ │ │ │ │ ├── bidirule.go │ │ │ │ ├── bidirule10.0.0.go │ │ │ │ └── bidirule9.0.0.go │ │ │ ├── transform/ │ │ │ │ └── transform.go │ │ │ └── unicode/ │ │ │ ├── bidi/ │ │ │ │ ├── bidi.go │ │ │ │ ├── bracket.go │ │ │ │ ├── core.go │ │ │ │ ├── gen.go │ │ │ │ ├── gen_ranges.go │ │ │ │ ├── gen_trieval.go │ │ │ │ ├── prop.go │ │ │ │ ├── tables10.0.0.go │ │ │ │ ├── tables9.0.0.go │ │ │ │ └── trieval.go │ │ │ ├── cldr/ │ │ │ │ ├── base.go │ │ │ │ ├── cldr.go │ │ │ │ ├── collate.go │ │ │ │ ├── decode.go │ │ │ │ ├── makexml.go │ │ │ │ ├── resolve.go │ │ │ │ ├── slice.go │ │ │ │ └── xml.go │ │ │ ├── norm/ │ │ │ │ ├── composition.go │ │ │ │ ├── forminfo.go │ │ │ │ ├── input.go │ │ │ │ ├── iter.go │ │ │ │ ├── maketables.go │ │ │ │ ├── normalize.go │ │ │ │ ├── readwriter.go │ │ │ │ ├── tables10.0.0.go │ │ │ │ ├── tables9.0.0.go │ │ │ │ ├── transform.go │ │ │ │ ├── trie.go │ │ │ │ └── triegen.go │ │ │ └── rangetable/ │ │ │ ├── gen.go │ │ │ ├── merge.go │ │ │ ├── rangetable.go │ │ │ ├── tables10.0.0.go │ │ │ └── tables9.0.0.go │ │ ├── time/ │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── PATENTS │ │ │ └── rate/ │ │ │ ├── rate.go │ │ │ ├── rate_go16.go │ │ │ └── rate_go17.go │ │ └── tools/ │ │ ├── AUTHORS │ │ ├── CONTRIBUTORS │ │ ├── LICENSE │ │ ├── PATENTS │ │ ├── cmd/ │ │ │ └── getgo/ │ │ │ └── LICENSE │ │ ├── go/ │ │ │ └── ast/ │ │ │ └── astutil/ │ │ │ ├── enclosing.go │ │ │ ├── imports.go │ │ │ ├── rewrite.go │ │ │ └── util.go │ │ ├── imports/ │ │ │ ├── fix.go │ │ │ ├── imports.go │ │ │ ├── mkindex.go │ │ │ ├── mkstdlib.go │ │ │ ├── sortimports.go │ │ │ └── zstdlib.go │ │ ├── internal/ │ │ │ ├── fastwalk/ │ │ │ │ ├── fastwalk.go │ │ │ │ ├── fastwalk_dirent_fileno.go │ │ │ │ ├── fastwalk_dirent_ino.go │ │ │ │ ├── fastwalk_dirent_namlen_bsd.go │ │ │ │ ├── fastwalk_dirent_namlen_linux.go │ │ │ │ ├── fastwalk_portable.go │ │ │ │ └── fastwalk_unix.go │ │ │ └── gopathwalk/ │ │ │ └── walk.go │ │ └── third_party/ │ │ ├── moduleloader/ │ │ │ └── LICENSE │ │ ├── typescript/ │ │ │ └── LICENSE │ │ └── webcomponents/ │ │ └── LICENSE │ ├── google.golang.org/ │ │ ├── api/ │ │ │ ├── AUTHORS │ │ │ ├── CONTRIBUTORS │ │ │ ├── LICENSE │ │ │ ├── googleapi/ │ │ │ │ ├── internal/ │ │ │ │ │ └── uritemplates/ │ │ │ │ │ └── LICENSE │ │ │ │ └── transport/ │ │ │ │ └── apikey.go │ │ │ ├── internal/ │ │ │ │ ├── creds.go │ │ │ │ ├── pool.go │ │ │ │ └── settings.go │ │ │ ├── iterator/ │ │ │ │ └── iterator.go │ │ │ ├── option/ │ │ │ │ ├── credentials_go19.go │ │ │ │ ├── credentials_notgo19.go │ │ │ │ └── option.go │ │ │ ├── support/ │ │ │ │ └── bundler/ │ │ │ │ └── bundler.go │ │ │ └── transport/ │ │ │ ├── dial.go │ │ │ ├── go19.go │ │ │ ├── grpc/ │ │ │ │ ├── dial.go │ │ │ │ ├── dial_appengine.go │ │ │ │ ├── go18.go │ │ │ │ └── not_go18.go │ │ │ ├── http/ │ │ │ │ ├── dial.go │ │ │ │ ├── dial_appengine.go │ │ │ │ ├── go18.go │ │ │ │ ├── internal/ │ │ │ │ │ └── propagation/ │ │ │ │ │ └── http.go │ │ │ │ └── not_go18.go │ │ │ └── not_go19.go │ │ ├── appengine/ │ │ │ ├── LICENSE │ │ │ ├── appengine.go │ │ │ ├── appengine_vm.go │ │ │ ├── errors.go │ │ │ ├── identity.go │ │ │ ├── internal/ │ │ │ │ ├── api.go │ │ │ │ ├── api_classic.go │ │ │ │ ├── api_common.go │ │ │ │ ├── app_id.go │ │ │ │ ├── app_identity/ │ │ │ │ │ └── app_identity_service.pb.go │ │ │ │ ├── base/ │ │ │ │ │ └── api_base.pb.go │ │ │ │ ├── datastore/ │ │ │ │ │ └── datastore_v3.pb.go │ │ │ │ ├── identity.go │ │ │ │ ├── identity_classic.go │ │ │ │ ├── identity_flex.go │ │ │ │ ├── identity_vm.go │ │ │ │ ├── internal.go │ │ │ │ ├── log/ │ │ │ │ │ └── log_service.pb.go │ │ │ │ ├── main.go │ │ │ │ ├── main_vm.go │ │ │ │ ├── metadata.go │ │ │ │ ├── modules/ │ │ │ │ │ └── modules_service.pb.go │ │ │ │ ├── net.go │ │ │ │ ├── remote_api/ │ │ │ │ │ └── remote_api.pb.go │ │ │ │ ├── socket/ │ │ │ │ │ └── socket_service.pb.go │ │ │ │ ├── transaction.go │ │ │ │ └── urlfetch/ │ │ │ │ └── urlfetch_service.pb.go │ │ │ ├── namespace.go │ │ │ ├── socket/ │ │ │ │ ├── doc.go │ │ │ │ ├── socket_classic.go │ │ │ │ └── socket_vm.go │ │ │ ├── timeout.go │ │ │ └── urlfetch/ │ │ │ └── urlfetch.go │ │ ├── genproto/ │ │ │ ├── LICENSE │ │ │ ├── googleapis/ │ │ │ │ ├── api/ │ │ │ │ │ └── annotations/ │ │ │ │ │ ├── annotations.pb.go │ │ │ │ │ └── http.pb.go │ │ │ │ ├── iam/ │ │ │ │ │ └── v1/ │ │ │ │ │ ├── iam_policy.pb.go │ │ │ │ │ └── policy.pb.go │ │ │ │ ├── pubsub/ │ │ │ │ │ └── v1/ │ │ │ │ │ └── pubsub.pb.go │ │ │ │ └── rpc/ │ │ │ │ └── status/ │ │ │ │ └── status.pb.go │ │ │ └── protobuf/ │ │ │ └── field_mask/ │ │ │ └── field_mask.pb.go │ │ └── grpc/ │ │ ├── AUTHORS │ │ ├── LICENSE │ │ ├── backoff.go │ │ ├── balancer/ │ │ │ ├── balancer.go │ │ │ ├── base/ │ │ │ │ ├── balancer.go │ │ │ │ └── base.go │ │ │ └── roundrobin/ │ │ │ └── roundrobin.go │ │ ├── balancer.go │ │ ├── balancer_conn_wrappers.go │ │ ├── balancer_v1_wrapper.go │ │ ├── call.go │ │ ├── clientconn.go │ │ ├── codec.go │ │ ├── codes/ │ │ │ ├── code_string.go │ │ │ └── codes.go │ │ ├── connectivity/ │ │ │ └── connectivity.go │ │ ├── credentials/ │ │ │ ├── credentials.go │ │ │ ├── go16.go │ │ │ ├── go17.go │ │ │ ├── go18.go │ │ │ ├── go19.go │ │ │ └── oauth/ │ │ │ └── oauth.go │ │ ├── dialoptions.go │ │ ├── doc.go │ │ ├── encoding/ │ │ │ ├── encoding.go │ │ │ └── proto/ │ │ │ └── proto.go │ │ ├── go16.go │ │ ├── go17.go │ │ ├── grpclog/ │ │ │ ├── grpclog.go │ │ │ ├── logger.go │ │ │ └── loggerv2.go │ │ ├── interceptor.go │ │ ├── internal/ │ │ │ ├── backoff/ │ │ │ │ └── backoff.go │ │ │ ├── channelz/ │ │ │ │ ├── funcs.go │ │ │ │ ├── types.go │ │ │ │ ├── types_linux.go │ │ │ │ ├── types_nonlinux.go │ │ │ │ ├── util_linux_go19.go │ │ │ │ └── util_nonlinux_pre_go19.go │ │ │ ├── envconfig/ │ │ │ │ └── envconfig.go │ │ │ ├── grpcrand/ │ │ │ │ └── grpcrand.go │ │ │ ├── internal.go │ │ │ └── transport/ │ │ │ ├── bdp_estimator.go │ │ │ ├── controlbuf.go │ │ │ ├── defaults.go │ │ │ ├── flowcontrol.go │ │ │ ├── go16.go │ │ │ ├── go17.go │ │ │ ├── handler_server.go │ │ │ ├── http2_client.go │ │ │ ├── http2_server.go │ │ │ ├── http_util.go │ │ │ ├── log.go │ │ │ └── transport.go │ │ ├── keepalive/ │ │ │ └── keepalive.go │ │ ├── metadata/ │ │ │ └── metadata.go │ │ ├── naming/ │ │ │ ├── dns_resolver.go │ │ │ ├── go17.go │ │ │ ├── go18.go │ │ │ └── naming.go │ │ ├── peer/ │ │ │ └── peer.go │ │ ├── picker_wrapper.go │ │ ├── pickfirst.go │ │ ├── proxy.go │ │ ├── resolver/ │ │ │ ├── dns/ │ │ │ │ ├── dns_resolver.go │ │ │ │ ├── go19.go │ │ │ │ └── pre_go19.go │ │ │ ├── passthrough/ │ │ │ │ └── passthrough.go │ │ │ └── resolver.go │ │ ├── resolver_conn_wrapper.go │ │ ├── rpc_util.go │ │ ├── server.go │ │ ├── service_config.go │ │ ├── stats/ │ │ │ ├── handlers.go │ │ │ └── stats.go │ │ ├── status/ │ │ │ ├── go16.go │ │ │ ├── go17.go │ │ │ └── status.go │ │ ├── stream.go │ │ ├── tap/ │ │ │ └── tap.go │ │ ├── trace.go │ │ └── version.go │ ├── gopkg.in/ │ │ ├── fsnotify.v1/ │ │ │ ├── AUTHORS │ │ │ ├── LICENSE │ │ │ ├── fen.go │ │ │ ├── fsnotify.go │ │ │ ├── inotify.go │ │ │ ├── inotify_poller.go │ │ │ ├── kqueue.go │ │ │ ├── open_mode_bsd.go │ │ │ ├── open_mode_darwin.go │ │ │ └── windows.go │ │ ├── go-playground/ │ │ │ └── webhooks.v5/ │ │ │ ├── LICENSE │ │ │ ├── github/ │ │ │ │ ├── github.go │ │ │ │ └── payload.go │ │ │ └── testdata/ │ │ │ └── docker/ │ │ │ └── docker_hub_build_notice.json │ │ ├── inf.v0/ │ │ │ ├── LICENSE │ │ │ ├── dec.go │ │ │ └── rounder.go │ │ ├── natefinch/ │ │ │ └── lumberjack.v2/ │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── chown.go │ │ │ ├── chown_linux.go │ │ │ ├── example_test.go │ │ │ ├── linux_test.go │ │ │ ├── lumberjack.go │ │ │ ├── lumberjack_test.go │ │ │ ├── rotate_test.go │ │ │ └── testing_test.go │ │ ├── tomb.v1/ │ │ │ ├── LICENSE │ │ │ └── tomb.go │ │ └── yaml.v2/ │ │ ├── LICENSE │ │ ├── LICENSE.libyaml │ │ ├── NOTICE │ │ ├── apic.go │ │ ├── decode.go │ │ ├── emitterc.go │ │ ├── encode.go │ │ ├── parserc.go │ │ ├── readerc.go │ │ ├── resolve.go │ │ ├── scannerc.go │ │ ├── sorter.go │ │ ├── writerc.go │ │ ├── yaml.go │ │ ├── yamlh.go │ │ └── yamlprivateh.go │ ├── k8s.io/ │ │ ├── api/ │ │ │ ├── LICENSE │ │ │ ├── admission/ │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── admissionregistration/ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── apps/ │ │ │ │ ├── v1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ ├── v1beta1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ └── v1beta2/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── authentication/ │ │ │ │ ├── v1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── authorization/ │ │ │ │ ├── v1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── autoscaling/ │ │ │ │ ├── v1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ ├── v2beta1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ └── v2beta2/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── batch/ │ │ │ │ ├── v1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ ├── v1beta1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ └── v2alpha1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── certificates/ │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── coordination/ │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── core/ │ │ │ │ └── v1/ │ │ │ │ ├── annotation_key_constants.go │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── objectreference.go │ │ │ │ ├── register.go │ │ │ │ ├── resource.go │ │ │ │ ├── taint.go │ │ │ │ ├── toleration.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── events/ │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── extensions/ │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── networking/ │ │ │ │ └── v1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── policy/ │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── rbac/ │ │ │ │ ├── v1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ ├── v1alpha1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── scheduling/ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── settings/ │ │ │ │ └── v1alpha1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ └── storage/ │ │ │ ├── v1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── v1alpha1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ └── v1beta1/ │ │ │ ├── doc.go │ │ │ ├── generated.pb.go │ │ │ ├── register.go │ │ │ ├── types.go │ │ │ ├── types_swagger_doc_generated.go │ │ │ └── zz_generated.deepcopy.go │ │ ├── apiextensions-apiserver/ │ │ │ ├── LICENSE │ │ │ └── pkg/ │ │ │ └── apis/ │ │ │ └── apiextensions/ │ │ │ ├── deepcopy.go │ │ │ ├── doc.go │ │ │ ├── helpers.go │ │ │ ├── register.go │ │ │ ├── types.go │ │ │ ├── types_jsonschema.go │ │ │ ├── v1beta1/ │ │ │ │ ├── conversion.go │ │ │ │ ├── deepcopy.go │ │ │ │ ├── defaults.go │ │ │ │ ├── doc.go │ │ │ │ ├── generated.pb.go │ │ │ │ ├── marshal.go │ │ │ │ ├── register.go │ │ │ │ ├── types.go │ │ │ │ ├── types_jsonschema.go │ │ │ │ ├── zz_generated.conversion.go │ │ │ │ ├── zz_generated.deepcopy.go │ │ │ │ └── zz_generated.defaults.go │ │ │ └── zz_generated.deepcopy.go │ │ ├── apimachinery/ │ │ │ ├── LICENSE │ │ │ ├── pkg/ │ │ │ │ ├── api/ │ │ │ │ │ ├── equality/ │ │ │ │ │ │ └── semantic.go │ │ │ │ │ ├── errors/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── errors.go │ │ │ │ │ ├── meta/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ ├── firsthit_restmapper.go │ │ │ │ │ │ ├── help.go │ │ │ │ │ │ ├── interfaces.go │ │ │ │ │ │ ├── lazy.go │ │ │ │ │ │ ├── meta.go │ │ │ │ │ │ ├── multirestmapper.go │ │ │ │ │ │ ├── priority.go │ │ │ │ │ │ └── restmapper.go │ │ │ │ │ ├── resource/ │ │ │ │ │ │ ├── amount.go │ │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ │ ├── math.go │ │ │ │ │ │ ├── quantity.go │ │ │ │ │ │ ├── quantity_proto.go │ │ │ │ │ │ ├── scale_int.go │ │ │ │ │ │ ├── suffix.go │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ └── validation/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generic.go │ │ │ │ │ └── objectmeta.go │ │ │ │ ├── apis/ │ │ │ │ │ └── meta/ │ │ │ │ │ ├── internalversion/ │ │ │ │ │ │ ├── conversion.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ ├── zz_generated.conversion.go │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── controller_ref.go │ │ │ │ │ │ ├── conversion.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── duration.go │ │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ │ ├── group_version.go │ │ │ │ │ │ ├── helpers.go │ │ │ │ │ │ ├── labels.go │ │ │ │ │ │ ├── meta.go │ │ │ │ │ │ ├── micro_time.go │ │ │ │ │ │ ├── micro_time_proto.go │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ ├── time.go │ │ │ │ │ │ ├── time_proto.go │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ │ ├── unstructured/ │ │ │ │ │ │ │ ├── helpers.go │ │ │ │ │ │ │ ├── unstructured.go │ │ │ │ │ │ │ ├── unstructured_list.go │ │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ │ ├── validation/ │ │ │ │ │ │ │ └── validation.go │ │ │ │ │ │ ├── watch.go │ │ │ │ │ │ ├── zz_generated.deepcopy.go │ │ │ │ │ │ └── zz_generated.defaults.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── conversion.go │ │ │ │ │ ├── deepcopy.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_swagger_doc_generated.go │ │ │ │ │ ├── zz_generated.deepcopy.go │ │ │ │ │ └── zz_generated.defaults.go │ │ │ │ ├── conversion/ │ │ │ │ │ ├── converter.go │ │ │ │ │ ├── deep_equal.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── helper.go │ │ │ │ │ └── queryparams/ │ │ │ │ │ ├── convert.go │ │ │ │ │ └── doc.go │ │ │ │ ├── fields/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── fields.go │ │ │ │ │ ├── requirements.go │ │ │ │ │ └── selector.go │ │ │ │ ├── labels/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── labels.go │ │ │ │ │ ├── selector.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ ├── runtime/ │ │ │ │ │ ├── codec.go │ │ │ │ │ ├── codec_check.go │ │ │ │ │ ├── conversion.go │ │ │ │ │ ├── converter.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── embedded.go │ │ │ │ │ ├── error.go │ │ │ │ │ ├── extension.go │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ ├── helper.go │ │ │ │ │ ├── interfaces.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── schema/ │ │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ │ ├── group_version.go │ │ │ │ │ │ └── interfaces.go │ │ │ │ │ ├── scheme.go │ │ │ │ │ ├── scheme_builder.go │ │ │ │ │ ├── serializer/ │ │ │ │ │ │ ├── codec_factory.go │ │ │ │ │ │ ├── json/ │ │ │ │ │ │ │ ├── json.go │ │ │ │ │ │ │ └── meta.go │ │ │ │ │ │ ├── negotiated_codec.go │ │ │ │ │ │ ├── protobuf/ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ └── protobuf.go │ │ │ │ │ │ ├── protobuf_extension.go │ │ │ │ │ │ ├── recognizer/ │ │ │ │ │ │ │ └── recognizer.go │ │ │ │ │ │ ├── streaming/ │ │ │ │ │ │ │ └── streaming.go │ │ │ │ │ │ └── versioning/ │ │ │ │ │ │ └── versioning.go │ │ │ │ │ ├── swagger_doc_generator.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── types_proto.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ ├── selection/ │ │ │ │ │ └── operator.go │ │ │ │ ├── types/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── namespacedname.go │ │ │ │ │ ├── nodename.go │ │ │ │ │ ├── patch.go │ │ │ │ │ └── uid.go │ │ │ │ ├── util/ │ │ │ │ │ ├── cache/ │ │ │ │ │ │ ├── cache.go │ │ │ │ │ │ └── lruexpirecache.go │ │ │ │ │ ├── clock/ │ │ │ │ │ │ └── clock.go │ │ │ │ │ ├── diff/ │ │ │ │ │ │ └── diff.go │ │ │ │ │ ├── errors/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── errors.go │ │ │ │ │ ├── framer/ │ │ │ │ │ │ └── framer.go │ │ │ │ │ ├── intstr/ │ │ │ │ │ │ ├── generated.pb.go │ │ │ │ │ │ └── intstr.go │ │ │ │ │ ├── json/ │ │ │ │ │ │ └── json.go │ │ │ │ │ ├── mergepatch/ │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ └── util.go │ │ │ │ │ ├── naming/ │ │ │ │ │ │ └── from_stack.go │ │ │ │ │ ├── net/ │ │ │ │ │ │ ├── http.go │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ ├── port_range.go │ │ │ │ │ │ ├── port_split.go │ │ │ │ │ │ └── util.go │ │ │ │ │ ├── runtime/ │ │ │ │ │ │ └── runtime.go │ │ │ │ │ ├── sets/ │ │ │ │ │ │ ├── byte.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── empty.go │ │ │ │ │ │ ├── int.go │ │ │ │ │ │ ├── int64.go │ │ │ │ │ │ └── string.go │ │ │ │ │ ├── strategicpatch/ │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ ├── meta.go │ │ │ │ │ │ ├── patch.go │ │ │ │ │ │ └── types.go │ │ │ │ │ ├── uuid/ │ │ │ │ │ │ └── uuid.go │ │ │ │ │ ├── validation/ │ │ │ │ │ │ ├── field/ │ │ │ │ │ │ │ ├── errors.go │ │ │ │ │ │ │ └── path.go │ │ │ │ │ │ └── validation.go │ │ │ │ │ ├── wait/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── wait.go │ │ │ │ │ └── yaml/ │ │ │ │ │ └── decoder.go │ │ │ │ ├── version/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── helpers.go │ │ │ │ │ └── types.go │ │ │ │ └── watch/ │ │ │ │ ├── doc.go │ │ │ │ ├── filter.go │ │ │ │ ├── mux.go │ │ │ │ ├── streamwatcher.go │ │ │ │ ├── watch.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ └── third_party/ │ │ │ └── forked/ │ │ │ └── golang/ │ │ │ ├── json/ │ │ │ │ └── fields.go │ │ │ └── reflect/ │ │ │ └── deep_equal.go │ │ ├── client-go/ │ │ │ ├── LICENSE │ │ │ ├── discovery/ │ │ │ │ ├── cached_discovery.go │ │ │ │ ├── discovery_client.go │ │ │ │ ├── doc.go │ │ │ │ ├── fake/ │ │ │ │ │ └── discovery.go │ │ │ │ ├── helper.go │ │ │ │ └── round_tripper.go │ │ │ ├── dynamic/ │ │ │ │ ├── fake/ │ │ │ │ │ └── simple.go │ │ │ │ ├── interface.go │ │ │ │ ├── scheme.go │ │ │ │ └── simple.go │ │ │ ├── informers/ │ │ │ │ ├── admissionregistration/ │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ ├── initializerconfiguration.go │ │ │ │ │ │ └── interface.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── mutatingwebhookconfiguration.go │ │ │ │ │ └── validatingwebhookconfiguration.go │ │ │ │ ├── apps/ │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── controllerrevision.go │ │ │ │ │ │ ├── daemonset.go │ │ │ │ │ │ ├── deployment.go │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ ├── replicaset.go │ │ │ │ │ │ └── statefulset.go │ │ │ │ │ ├── v1beta1/ │ │ │ │ │ │ ├── controllerrevision.go │ │ │ │ │ │ ├── deployment.go │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ └── statefulset.go │ │ │ │ │ └── v1beta2/ │ │ │ │ │ ├── controllerrevision.go │ │ │ │ │ ├── daemonset.go │ │ │ │ │ ├── deployment.go │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── replicaset.go │ │ │ │ │ └── statefulset.go │ │ │ │ ├── autoscaling/ │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── horizontalpodautoscaler.go │ │ │ │ │ │ └── interface.go │ │ │ │ │ ├── v2beta1/ │ │ │ │ │ │ ├── horizontalpodautoscaler.go │ │ │ │ │ │ └── interface.go │ │ │ │ │ └── v2beta2/ │ │ │ │ │ ├── horizontalpodautoscaler.go │ │ │ │ │ └── interface.go │ │ │ │ ├── batch/ │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ └── job.go │ │ │ │ │ ├── v1beta1/ │ │ │ │ │ │ ├── cronjob.go │ │ │ │ │ │ └── interface.go │ │ │ │ │ └── v2alpha1/ │ │ │ │ │ ├── cronjob.go │ │ │ │ │ └── interface.go │ │ │ │ ├── certificates/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── certificatesigningrequest.go │ │ │ │ │ └── interface.go │ │ │ │ ├── coordination/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── lease.go │ │ │ │ ├── core/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── v1/ │ │ │ │ │ ├── componentstatus.go │ │ │ │ │ ├── configmap.go │ │ │ │ │ ├── endpoints.go │ │ │ │ │ ├── event.go │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── limitrange.go │ │ │ │ │ ├── namespace.go │ │ │ │ │ ├── node.go │ │ │ │ │ ├── persistentvolume.go │ │ │ │ │ ├── persistentvolumeclaim.go │ │ │ │ │ ├── pod.go │ │ │ │ │ ├── podtemplate.go │ │ │ │ │ ├── replicationcontroller.go │ │ │ │ │ ├── resourcequota.go │ │ │ │ │ ├── secret.go │ │ │ │ │ ├── service.go │ │ │ │ │ └── serviceaccount.go │ │ │ │ ├── events/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── event.go │ │ │ │ │ └── interface.go │ │ │ │ ├── extensions/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── daemonset.go │ │ │ │ │ ├── deployment.go │ │ │ │ │ ├── ingress.go │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── podsecuritypolicy.go │ │ │ │ │ └── replicaset.go │ │ │ │ ├── factory.go │ │ │ │ ├── generic.go │ │ │ │ ├── internalinterfaces/ │ │ │ │ │ └── factory_interfaces.go │ │ │ │ ├── networking/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── v1/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── networkpolicy.go │ │ │ │ ├── policy/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── poddisruptionbudget.go │ │ │ │ │ └── podsecuritypolicy.go │ │ │ │ ├── rbac/ │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── clusterrole.go │ │ │ │ │ │ ├── clusterrolebinding.go │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ ├── role.go │ │ │ │ │ │ └── rolebinding.go │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ ├── clusterrole.go │ │ │ │ │ │ ├── clusterrolebinding.go │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ ├── role.go │ │ │ │ │ │ └── rolebinding.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── clusterrole.go │ │ │ │ │ ├── clusterrolebinding.go │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── role.go │ │ │ │ │ └── rolebinding.go │ │ │ │ ├── scheduling/ │ │ │ │ │ ├── interface.go │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ └── priorityclass.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── priorityclass.go │ │ │ │ ├── settings/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── podpreset.go │ │ │ │ └── storage/ │ │ │ │ ├── interface.go │ │ │ │ ├── v1/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── storageclass.go │ │ │ │ ├── v1alpha1/ │ │ │ │ │ ├── interface.go │ │ │ │ │ └── volumeattachment.go │ │ │ │ └── v1beta1/ │ │ │ │ ├── interface.go │ │ │ │ ├── storageclass.go │ │ │ │ └── volumeattachment.go │ │ │ ├── kubernetes/ │ │ │ │ ├── clientset.go │ │ │ │ ├── doc.go │ │ │ │ ├── import.go │ │ │ │ ├── scheme/ │ │ │ │ │ ├── doc.go │ │ │ │ │ └── register.go │ │ │ │ └── typed/ │ │ │ │ ├── admissionregistration/ │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ ├── admissionregistration_client.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ └── initializerconfiguration.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── admissionregistration_client.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── mutatingwebhookconfiguration.go │ │ │ │ │ └── validatingwebhookconfiguration.go │ │ │ │ ├── apps/ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── apps_client.go │ │ │ │ │ │ ├── controllerrevision.go │ │ │ │ │ │ ├── daemonset.go │ │ │ │ │ │ ├── deployment.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ ├── replicaset.go │ │ │ │ │ │ └── statefulset.go │ │ │ │ │ ├── v1beta1/ │ │ │ │ │ │ ├── apps_client.go │ │ │ │ │ │ ├── controllerrevision.go │ │ │ │ │ │ ├── deployment.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ ├── scale.go │ │ │ │ │ │ └── statefulset.go │ │ │ │ │ └── v1beta2/ │ │ │ │ │ ├── apps_client.go │ │ │ │ │ ├── controllerrevision.go │ │ │ │ │ ├── daemonset.go │ │ │ │ │ ├── deployment.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── replicaset.go │ │ │ │ │ ├── scale.go │ │ │ │ │ └── statefulset.go │ │ │ │ ├── authentication/ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── authentication_client.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ ├── tokenreview.go │ │ │ │ │ │ └── tokenreview_expansion.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── authentication_client.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── tokenreview.go │ │ │ │ │ └── tokenreview_expansion.go │ │ │ │ ├── authorization/ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── authorization_client.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ ├── localsubjectaccessreview.go │ │ │ │ │ │ ├── localsubjectaccessreview_expansion.go │ │ │ │ │ │ ├── selfsubjectaccessreview.go │ │ │ │ │ │ ├── selfsubjectaccessreview_expansion.go │ │ │ │ │ │ ├── selfsubjectrulesreview.go │ │ │ │ │ │ ├── selfsubjectrulesreview_expansion.go │ │ │ │ │ │ ├── subjectaccessreview.go │ │ │ │ │ │ └── subjectaccessreview_expansion.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── authorization_client.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── localsubjectaccessreview.go │ │ │ │ │ ├── localsubjectaccessreview_expansion.go │ │ │ │ │ ├── selfsubjectaccessreview.go │ │ │ │ │ ├── selfsubjectaccessreview_expansion.go │ │ │ │ │ ├── selfsubjectrulesreview.go │ │ │ │ │ ├── selfsubjectrulesreview_expansion.go │ │ │ │ │ ├── subjectaccessreview.go │ │ │ │ │ └── subjectaccessreview_expansion.go │ │ │ │ ├── autoscaling/ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── autoscaling_client.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ └── horizontalpodautoscaler.go │ │ │ │ │ ├── v2beta1/ │ │ │ │ │ │ ├── autoscaling_client.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ └── horizontalpodautoscaler.go │ │ │ │ │ └── v2beta2/ │ │ │ │ │ ├── autoscaling_client.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ └── horizontalpodautoscaler.go │ │ │ │ ├── batch/ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── batch_client.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ └── job.go │ │ │ │ │ ├── v1beta1/ │ │ │ │ │ │ ├── batch_client.go │ │ │ │ │ │ ├── cronjob.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── generated_expansion.go │ │ │ │ │ └── v2alpha1/ │ │ │ │ │ ├── batch_client.go │ │ │ │ │ ├── cronjob.go │ │ │ │ │ ├── doc.go │ │ │ │ │ └── generated_expansion.go │ │ │ │ ├── certificates/ │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── certificates_client.go │ │ │ │ │ ├── certificatesigningrequest.go │ │ │ │ │ ├── certificatesigningrequest_expansion.go │ │ │ │ │ ├── doc.go │ │ │ │ │ └── generated_expansion.go │ │ │ │ ├── coordination/ │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── coordination_client.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ └── lease.go │ │ │ │ ├── core/ │ │ │ │ │ └── v1/ │ │ │ │ │ ├── componentstatus.go │ │ │ │ │ ├── configmap.go │ │ │ │ │ ├── core_client.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── endpoints.go │ │ │ │ │ ├── event.go │ │ │ │ │ ├── event_expansion.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── limitrange.go │ │ │ │ │ ├── namespace.go │ │ │ │ │ ├── namespace_expansion.go │ │ │ │ │ ├── node.go │ │ │ │ │ ├── node_expansion.go │ │ │ │ │ ├── persistentvolume.go │ │ │ │ │ ├── persistentvolumeclaim.go │ │ │ │ │ ├── pod.go │ │ │ │ │ ├── pod_expansion.go │ │ │ │ │ ├── podtemplate.go │ │ │ │ │ ├── replicationcontroller.go │ │ │ │ │ ├── resourcequota.go │ │ │ │ │ ├── secret.go │ │ │ │ │ ├── service.go │ │ │ │ │ ├── service_expansion.go │ │ │ │ │ ├── serviceaccount.go │ │ │ │ │ └── serviceaccount_expansion.go │ │ │ │ ├── events/ │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── event.go │ │ │ │ │ ├── events_client.go │ │ │ │ │ └── generated_expansion.go │ │ │ │ ├── extensions/ │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── daemonset.go │ │ │ │ │ ├── deployment.go │ │ │ │ │ ├── deployment_expansion.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── extensions_client.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── ingress.go │ │ │ │ │ ├── podsecuritypolicy.go │ │ │ │ │ ├── replicaset.go │ │ │ │ │ ├── scale.go │ │ │ │ │ └── scale_expansion.go │ │ │ │ ├── networking/ │ │ │ │ │ └── v1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── networking_client.go │ │ │ │ │ └── networkpolicy.go │ │ │ │ ├── policy/ │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── eviction.go │ │ │ │ │ ├── eviction_expansion.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── poddisruptionbudget.go │ │ │ │ │ ├── podsecuritypolicy.go │ │ │ │ │ └── policy_client.go │ │ │ │ ├── rbac/ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── clusterrole.go │ │ │ │ │ │ ├── clusterrolebinding.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ ├── rbac_client.go │ │ │ │ │ │ ├── role.go │ │ │ │ │ │ └── rolebinding.go │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ ├── clusterrole.go │ │ │ │ │ │ ├── clusterrolebinding.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ ├── rbac_client.go │ │ │ │ │ │ ├── role.go │ │ │ │ │ │ └── rolebinding.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── clusterrole.go │ │ │ │ │ ├── clusterrolebinding.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── rbac_client.go │ │ │ │ │ ├── role.go │ │ │ │ │ └── rolebinding.go │ │ │ │ ├── scheduling/ │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ ├── priorityclass.go │ │ │ │ │ │ └── scheduling_client.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── priorityclass.go │ │ │ │ │ └── scheduling_client.go │ │ │ │ ├── settings/ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── podpreset.go │ │ │ │ │ └── settings_client.go │ │ │ │ └── storage/ │ │ │ │ ├── v1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── storage_client.go │ │ │ │ │ └── storageclass.go │ │ │ │ ├── v1alpha1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ ├── storage_client.go │ │ │ │ │ └── volumeattachment.go │ │ │ │ └── v1beta1/ │ │ │ │ ├── doc.go │ │ │ │ ├── generated_expansion.go │ │ │ │ ├── storage_client.go │ │ │ │ ├── storageclass.go │ │ │ │ └── volumeattachment.go │ │ │ ├── listers/ │ │ │ │ ├── admissionregistration/ │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ └── initializerconfiguration.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ ├── mutatingwebhookconfiguration.go │ │ │ │ │ └── validatingwebhookconfiguration.go │ │ │ │ ├── apps/ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── controllerrevision.go │ │ │ │ │ │ ├── daemonset.go │ │ │ │ │ │ ├── daemonset_expansion.go │ │ │ │ │ │ ├── deployment.go │ │ │ │ │ │ ├── deployment_expansion.go │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ ├── replicaset.go │ │ │ │ │ │ ├── replicaset_expansion.go │ │ │ │ │ │ ├── statefulset.go │ │ │ │ │ │ └── statefulset_expansion.go │ │ │ │ │ ├── v1beta1/ │ │ │ │ │ │ ├── controllerrevision.go │ │ │ │ │ │ ├── deployment.go │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ ├── scale.go │ │ │ │ │ │ ├── statefulset.go │ │ │ │ │ │ └── statefulset_expansion.go │ │ │ │ │ └── v1beta2/ │ │ │ │ │ ├── controllerrevision.go │ │ │ │ │ ├── daemonset.go │ │ │ │ │ ├── daemonset_expansion.go │ │ │ │ │ ├── deployment.go │ │ │ │ │ ├── deployment_expansion.go │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ ├── replicaset.go │ │ │ │ │ ├── replicaset_expansion.go │ │ │ │ │ ├── scale.go │ │ │ │ │ ├── statefulset.go │ │ │ │ │ └── statefulset_expansion.go │ │ │ │ ├── autoscaling/ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ └── horizontalpodautoscaler.go │ │ │ │ │ ├── v2beta1/ │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ └── horizontalpodautoscaler.go │ │ │ │ │ └── v2beta2/ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ └── horizontalpodautoscaler.go │ │ │ │ ├── batch/ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ ├── job.go │ │ │ │ │ │ └── job_expansion.go │ │ │ │ │ ├── v1beta1/ │ │ │ │ │ │ ├── cronjob.go │ │ │ │ │ │ └── expansion_generated.go │ │ │ │ │ └── v2alpha1/ │ │ │ │ │ ├── cronjob.go │ │ │ │ │ └── expansion_generated.go │ │ │ │ ├── certificates/ │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── certificatesigningrequest.go │ │ │ │ │ └── expansion_generated.go │ │ │ │ ├── coordination/ │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ └── lease.go │ │ │ │ ├── core/ │ │ │ │ │ └── v1/ │ │ │ │ │ ├── componentstatus.go │ │ │ │ │ ├── configmap.go │ │ │ │ │ ├── endpoints.go │ │ │ │ │ ├── event.go │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ ├── limitrange.go │ │ │ │ │ ├── namespace.go │ │ │ │ │ ├── node.go │ │ │ │ │ ├── node_expansion.go │ │ │ │ │ ├── persistentvolume.go │ │ │ │ │ ├── persistentvolumeclaim.go │ │ │ │ │ ├── pod.go │ │ │ │ │ ├── podtemplate.go │ │ │ │ │ ├── replicationcontroller.go │ │ │ │ │ ├── replicationcontroller_expansion.go │ │ │ │ │ ├── resourcequota.go │ │ │ │ │ ├── secret.go │ │ │ │ │ ├── service.go │ │ │ │ │ ├── service_expansion.go │ │ │ │ │ └── serviceaccount.go │ │ │ │ ├── events/ │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── event.go │ │ │ │ │ └── expansion_generated.go │ │ │ │ ├── extensions/ │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── daemonset.go │ │ │ │ │ ├── daemonset_expansion.go │ │ │ │ │ ├── deployment.go │ │ │ │ │ ├── deployment_expansion.go │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ ├── ingress.go │ │ │ │ │ ├── podsecuritypolicy.go │ │ │ │ │ ├── replicaset.go │ │ │ │ │ ├── replicaset_expansion.go │ │ │ │ │ └── scale.go │ │ │ │ ├── networking/ │ │ │ │ │ └── v1/ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ └── networkpolicy.go │ │ │ │ ├── policy/ │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── eviction.go │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ ├── poddisruptionbudget.go │ │ │ │ │ ├── poddisruptionbudget_expansion.go │ │ │ │ │ └── podsecuritypolicy.go │ │ │ │ ├── rbac/ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ ├── clusterrole.go │ │ │ │ │ │ ├── clusterrolebinding.go │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ ├── role.go │ │ │ │ │ │ └── rolebinding.go │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ ├── clusterrole.go │ │ │ │ │ │ ├── clusterrolebinding.go │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ ├── role.go │ │ │ │ │ │ └── rolebinding.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── clusterrole.go │ │ │ │ │ ├── clusterrolebinding.go │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ ├── role.go │ │ │ │ │ └── rolebinding.go │ │ │ │ ├── scheduling/ │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ └── priorityclass.go │ │ │ │ │ └── v1beta1/ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ └── priorityclass.go │ │ │ │ ├── settings/ │ │ │ │ │ └── v1alpha1/ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ └── podpreset.go │ │ │ │ └── storage/ │ │ │ │ ├── v1/ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ └── storageclass.go │ │ │ │ ├── v1alpha1/ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ └── volumeattachment.go │ │ │ │ └── v1beta1/ │ │ │ │ ├── expansion_generated.go │ │ │ │ ├── storageclass.go │ │ │ │ └── volumeattachment.go │ │ │ ├── pkg/ │ │ │ │ ├── apis/ │ │ │ │ │ └── clientauthentication/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── v1alpha1/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ ├── zz_generated.conversion.go │ │ │ │ │ │ ├── zz_generated.deepcopy.go │ │ │ │ │ │ └── zz_generated.defaults.go │ │ │ │ │ ├── v1beta1/ │ │ │ │ │ │ ├── conversion.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ ├── zz_generated.conversion.go │ │ │ │ │ │ ├── zz_generated.deepcopy.go │ │ │ │ │ │ └── zz_generated.defaults.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ └── version/ │ │ │ │ ├── base.go │ │ │ │ ├── doc.go │ │ │ │ └── version.go │ │ │ ├── plugin/ │ │ │ │ └── pkg/ │ │ │ │ └── client/ │ │ │ │ └── auth/ │ │ │ │ ├── exec/ │ │ │ │ │ └── exec.go │ │ │ │ └── gcp/ │ │ │ │ └── gcp.go │ │ │ ├── rest/ │ │ │ │ ├── client.go │ │ │ │ ├── config.go │ │ │ │ ├── plugin.go │ │ │ │ ├── request.go │ │ │ │ ├── transport.go │ │ │ │ ├── url_utils.go │ │ │ │ ├── urlbackoff.go │ │ │ │ ├── watch/ │ │ │ │ │ ├── decoder.go │ │ │ │ │ └── encoder.go │ │ │ │ └── zz_generated.deepcopy.go │ │ │ ├── restmapper/ │ │ │ │ ├── category_expansion.go │ │ │ │ ├── discovery.go │ │ │ │ └── shortcut.go │ │ │ ├── testing/ │ │ │ │ ├── actions.go │ │ │ │ ├── fake.go │ │ │ │ └── fixture.go │ │ │ ├── third_party/ │ │ │ │ └── forked/ │ │ │ │ └── golang/ │ │ │ │ └── template/ │ │ │ │ ├── exec.go │ │ │ │ └── funcs.go │ │ │ ├── tools/ │ │ │ │ ├── auth/ │ │ │ │ │ └── clientauth.go │ │ │ │ ├── cache/ │ │ │ │ │ ├── controller.go │ │ │ │ │ ├── delta_fifo.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── expiration_cache.go │ │ │ │ │ ├── expiration_cache_fakes.go │ │ │ │ │ ├── fake_custom_store.go │ │ │ │ │ ├── fifo.go │ │ │ │ │ ├── heap.go │ │ │ │ │ ├── index.go │ │ │ │ │ ├── listers.go │ │ │ │ │ ├── listwatch.go │ │ │ │ │ ├── mutation_cache.go │ │ │ │ │ ├── mutation_detector.go │ │ │ │ │ ├── reflector.go │ │ │ │ │ ├── reflector_metrics.go │ │ │ │ │ ├── shared_informer.go │ │ │ │ │ ├── store.go │ │ │ │ │ ├── thread_safe_store.go │ │ │ │ │ └── undelta_store.go │ │ │ │ ├── clientcmd/ │ │ │ │ │ ├── api/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── helpers.go │ │ │ │ │ │ ├── latest/ │ │ │ │ │ │ │ └── latest.go │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ │ ├── conversion.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ ├── auth_loaders.go │ │ │ │ │ ├── client_config.go │ │ │ │ │ ├── config.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── flag.go │ │ │ │ │ ├── helpers.go │ │ │ │ │ ├── loader.go │ │ │ │ │ ├── merged_client_builder.go │ │ │ │ │ ├── overrides.go │ │ │ │ │ └── validation.go │ │ │ │ ├── leaderelection/ │ │ │ │ │ ├── healthzadaptor.go │ │ │ │ │ ├── leaderelection.go │ │ │ │ │ └── resourcelock/ │ │ │ │ │ ├── configmaplock.go │ │ │ │ │ ├── endpointslock.go │ │ │ │ │ └── interface.go │ │ │ │ ├── metrics/ │ │ │ │ │ └── metrics.go │ │ │ │ ├── pager/ │ │ │ │ │ └── pager.go │ │ │ │ ├── record/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── event.go │ │ │ │ │ ├── events_cache.go │ │ │ │ │ └── fake.go │ │ │ │ └── reference/ │ │ │ │ └── ref.go │ │ │ ├── transport/ │ │ │ │ ├── cache.go │ │ │ │ ├── config.go │ │ │ │ ├── round_trippers.go │ │ │ │ ├── token_source.go │ │ │ │ └── transport.go │ │ │ └── util/ │ │ │ ├── buffer/ │ │ │ │ └── ring_growing.go │ │ │ ├── cert/ │ │ │ │ ├── cert.go │ │ │ │ ├── csr.go │ │ │ │ ├── io.go │ │ │ │ └── pem.go │ │ │ ├── connrotation/ │ │ │ │ └── connrotation.go │ │ │ ├── flowcontrol/ │ │ │ │ ├── backoff.go │ │ │ │ └── throttle.go │ │ │ ├── homedir/ │ │ │ │ └── homedir.go │ │ │ ├── integer/ │ │ │ │ └── integer.go │ │ │ ├── jsonpath/ │ │ │ │ ├── doc.go │ │ │ │ ├── jsonpath.go │ │ │ │ ├── node.go │ │ │ │ └── parser.go │ │ │ ├── retry/ │ │ │ │ └── util.go │ │ │ └── workqueue/ │ │ │ ├── default_rate_limiters.go │ │ │ ├── delaying_queue.go │ │ │ ├── doc.go │ │ │ ├── metrics.go │ │ │ ├── parallelizer.go │ │ │ ├── queue.go │ │ │ └── rate_limitting_queue.go │ │ ├── code-generator/ │ │ │ ├── .github/ │ │ │ │ └── PULL_REQUEST_TEMPLATE.md │ │ │ ├── CONTRIBUTING.md │ │ │ ├── Godeps/ │ │ │ │ ├── Godeps.json │ │ │ │ └── Readme │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── SECURITY_CONTACTS │ │ │ ├── _examples/ │ │ │ │ ├── apiserver/ │ │ │ │ │ ├── apis/ │ │ │ │ │ │ ├── example/ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── install/ │ │ │ │ │ │ │ │ └── install.go │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ │ │ ├── zz_generated.conversion.go │ │ │ │ │ │ │ │ ├── zz_generated.deepcopy.go │ │ │ │ │ │ │ │ └── zz_generated.defaults.go │ │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ │ └── example2/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── install/ │ │ │ │ │ │ │ └── install.go │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ ├── v1/ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ │ ├── zz_generated.conversion.go │ │ │ │ │ │ │ ├── zz_generated.deepcopy.go │ │ │ │ │ │ │ └── zz_generated.defaults.go │ │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ │ ├── clientset/ │ │ │ │ │ │ ├── internalversion/ │ │ │ │ │ │ │ ├── clientset.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── fake/ │ │ │ │ │ │ │ │ ├── clientset_generated.go │ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ │ └── register.go │ │ │ │ │ │ │ ├── scheme/ │ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ │ └── register.go │ │ │ │ │ │ │ └── typed/ │ │ │ │ │ │ │ ├── example/ │ │ │ │ │ │ │ │ └── internalversion/ │ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ │ ├── example_client.go │ │ │ │ │ │ │ │ ├── fake/ │ │ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ │ │ ├── fake_example_client.go │ │ │ │ │ │ │ │ │ └── fake_testtype.go │ │ │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ │ │ └── testtype.go │ │ │ │ │ │ │ └── example2/ │ │ │ │ │ │ │ └── internalversion/ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── example2_client.go │ │ │ │ │ │ │ ├── fake/ │ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ │ ├── fake_example2_client.go │ │ │ │ │ │ │ │ └── fake_testtype.go │ │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ │ └── testtype.go │ │ │ │ │ │ └── versioned/ │ │ │ │ │ │ ├── clientset.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── fake/ │ │ │ │ │ │ │ ├── clientset_generated.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ └── register.go │ │ │ │ │ │ ├── scheme/ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ └── register.go │ │ │ │ │ │ └── typed/ │ │ │ │ │ │ ├── example/ │ │ │ │ │ │ │ └── v1/ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── example_client.go │ │ │ │ │ │ │ ├── fake/ │ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ │ ├── fake_example_client.go │ │ │ │ │ │ │ │ └── fake_testtype.go │ │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ │ └── testtype.go │ │ │ │ │ │ └── example2/ │ │ │ │ │ │ └── v1/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── example2_client.go │ │ │ │ │ │ ├── fake/ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── fake_example2_client.go │ │ │ │ │ │ │ └── fake_testtype.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ └── testtype.go │ │ │ │ │ ├── informers/ │ │ │ │ │ │ ├── externalversions/ │ │ │ │ │ │ │ ├── example/ │ │ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ │ │ └── v1/ │ │ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ │ │ └── testtype.go │ │ │ │ │ │ │ ├── example2/ │ │ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ │ │ └── v1/ │ │ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ │ │ └── testtype.go │ │ │ │ │ │ │ ├── factory.go │ │ │ │ │ │ │ ├── generic.go │ │ │ │ │ │ │ └── internalinterfaces/ │ │ │ │ │ │ │ └── factory_interfaces.go │ │ │ │ │ │ └── internalversion/ │ │ │ │ │ │ ├── example/ │ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ │ └── internalversion/ │ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ │ └── testtype.go │ │ │ │ │ │ ├── example2/ │ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ │ └── internalversion/ │ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ │ └── testtype.go │ │ │ │ │ │ ├── factory.go │ │ │ │ │ │ ├── generic.go │ │ │ │ │ │ └── internalinterfaces/ │ │ │ │ │ │ └── factory_interfaces.go │ │ │ │ │ └── listers/ │ │ │ │ │ ├── example/ │ │ │ │ │ │ ├── internalversion/ │ │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ │ └── testtype.go │ │ │ │ │ │ └── v1/ │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ └── testtype.go │ │ │ │ │ └── example2/ │ │ │ │ │ ├── internalversion/ │ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ │ └── testtype.go │ │ │ │ │ └── v1/ │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ └── testtype.go │ │ │ │ └── crd/ │ │ │ │ ├── apis/ │ │ │ │ │ ├── example/ │ │ │ │ │ │ └── v1/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── register.go │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ ├── zz_generated.deepcopy.go │ │ │ │ │ │ └── zz_generated.defaults.go │ │ │ │ │ └── example2/ │ │ │ │ │ └── v1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── types.go │ │ │ │ │ ├── zz_generated.deepcopy.go │ │ │ │ │ └── zz_generated.defaults.go │ │ │ │ ├── clientset/ │ │ │ │ │ └── versioned/ │ │ │ │ │ ├── clientset.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── fake/ │ │ │ │ │ │ ├── clientset_generated.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── register.go │ │ │ │ │ ├── scheme/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── register.go │ │ │ │ │ └── typed/ │ │ │ │ │ ├── example/ │ │ │ │ │ │ └── v1/ │ │ │ │ │ │ ├── clustertesttype.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── example_client.go │ │ │ │ │ │ ├── fake/ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── fake_clustertesttype.go │ │ │ │ │ │ │ ├── fake_example_client.go │ │ │ │ │ │ │ └── fake_testtype.go │ │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ │ └── testtype.go │ │ │ │ │ └── example2/ │ │ │ │ │ └── v1/ │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── example2_client.go │ │ │ │ │ ├── fake/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── fake_example2_client.go │ │ │ │ │ │ └── fake_testtype.go │ │ │ │ │ ├── generated_expansion.go │ │ │ │ │ └── testtype.go │ │ │ │ ├── informers/ │ │ │ │ │ └── externalversions/ │ │ │ │ │ ├── example/ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ └── v1/ │ │ │ │ │ │ ├── clustertesttype.go │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ └── testtype.go │ │ │ │ │ ├── example2/ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ └── v1/ │ │ │ │ │ │ ├── interface.go │ │ │ │ │ │ └── testtype.go │ │ │ │ │ ├── factory.go │ │ │ │ │ ├── generic.go │ │ │ │ │ └── internalinterfaces/ │ │ │ │ │ └── factory_interfaces.go │ │ │ │ └── listers/ │ │ │ │ ├── example/ │ │ │ │ │ └── v1/ │ │ │ │ │ ├── clustertesttype.go │ │ │ │ │ ├── expansion_generated.go │ │ │ │ │ └── testtype.go │ │ │ │ └── example2/ │ │ │ │ └── v1/ │ │ │ │ ├── expansion_generated.go │ │ │ │ └── testtype.go │ │ │ ├── cmd/ │ │ │ │ ├── client-gen/ │ │ │ │ │ ├── README.md │ │ │ │ │ ├── args/ │ │ │ │ │ │ ├── args.go │ │ │ │ │ │ ├── gvpackages.go │ │ │ │ │ │ └── gvtype.go │ │ │ │ │ ├── generators/ │ │ │ │ │ │ ├── client_generator.go │ │ │ │ │ │ ├── fake/ │ │ │ │ │ │ │ ├── fake_client_generator.go │ │ │ │ │ │ │ ├── generator_fake_for_clientset.go │ │ │ │ │ │ │ ├── generator_fake_for_group.go │ │ │ │ │ │ │ └── generator_fake_for_type.go │ │ │ │ │ │ ├── generator_for_clientset.go │ │ │ │ │ │ ├── generator_for_expansion.go │ │ │ │ │ │ ├── generator_for_group.go │ │ │ │ │ │ ├── generator_for_type.go │ │ │ │ │ │ ├── scheme/ │ │ │ │ │ │ │ └── generator_for_scheme.go │ │ │ │ │ │ ├── tags.go │ │ │ │ │ │ └── util/ │ │ │ │ │ │ └── tags.go │ │ │ │ │ ├── main.go │ │ │ │ │ ├── path/ │ │ │ │ │ │ └── path.go │ │ │ │ │ └── types/ │ │ │ │ │ ├── helpers.go │ │ │ │ │ └── types.go │ │ │ │ ├── conversion-gen/ │ │ │ │ │ ├── args/ │ │ │ │ │ │ └── args.go │ │ │ │ │ ├── generators/ │ │ │ │ │ │ └── conversion.go │ │ │ │ │ └── main.go │ │ │ │ ├── deepcopy-gen/ │ │ │ │ │ ├── args/ │ │ │ │ │ │ └── args.go │ │ │ │ │ └── main.go │ │ │ │ ├── defaulter-gen/ │ │ │ │ │ ├── args/ │ │ │ │ │ │ └── args.go │ │ │ │ │ └── main.go │ │ │ │ ├── go-to-protobuf/ │ │ │ │ │ ├── main.go │ │ │ │ │ ├── protobuf/ │ │ │ │ │ │ ├── cmd.go │ │ │ │ │ │ ├── generator.go │ │ │ │ │ │ ├── import_tracker.go │ │ │ │ │ │ ├── namer.go │ │ │ │ │ │ ├── package.go │ │ │ │ │ │ ├── parser.go │ │ │ │ │ │ └── tags.go │ │ │ │ │ └── protoc-gen-gogo/ │ │ │ │ │ └── main.go │ │ │ │ ├── import-boss/ │ │ │ │ │ └── main.go │ │ │ │ ├── informer-gen/ │ │ │ │ │ ├── args/ │ │ │ │ │ │ └── args.go │ │ │ │ │ ├── generators/ │ │ │ │ │ │ ├── factory.go │ │ │ │ │ │ ├── factoryinterface.go │ │ │ │ │ │ ├── generic.go │ │ │ │ │ │ ├── groupinterface.go │ │ │ │ │ │ ├── informer.go │ │ │ │ │ │ ├── packages.go │ │ │ │ │ │ ├── tags.go │ │ │ │ │ │ ├── types.go │ │ │ │ │ │ └── versioninterface.go │ │ │ │ │ └── main.go │ │ │ │ ├── lister-gen/ │ │ │ │ │ ├── .import-restrictions │ │ │ │ │ ├── args/ │ │ │ │ │ │ └── args.go │ │ │ │ │ ├── generators/ │ │ │ │ │ │ ├── expansion.go │ │ │ │ │ │ ├── lister.go │ │ │ │ │ │ └── tags.go │ │ │ │ │ └── main.go │ │ │ │ ├── openapi-gen/ │ │ │ │ │ ├── README │ │ │ │ │ ├── args/ │ │ │ │ │ │ └── args.go │ │ │ │ │ └── main.go │ │ │ │ ├── register-gen/ │ │ │ │ │ ├── args/ │ │ │ │ │ │ └── args.go │ │ │ │ │ ├── generators/ │ │ │ │ │ │ ├── packages.go │ │ │ │ │ │ └── register_external.go │ │ │ │ │ └── main.go │ │ │ │ └── set-gen/ │ │ │ │ └── main.go │ │ │ ├── code-of-conduct.md │ │ │ ├── generate-groups.sh │ │ │ ├── generate-internal-groups.sh │ │ │ ├── hack/ │ │ │ │ ├── boilerplate.go.txt │ │ │ │ ├── update-codegen.sh │ │ │ │ └── verify-codegen.sh │ │ │ ├── pkg/ │ │ │ │ └── util/ │ │ │ │ └── build.go │ │ │ └── third_party/ │ │ │ └── forked/ │ │ │ └── golang/ │ │ │ └── reflect/ │ │ │ └── type.go │ │ ├── gengo/ │ │ │ ├── LICENSE │ │ │ ├── args/ │ │ │ │ └── args.go │ │ │ ├── examples/ │ │ │ │ ├── deepcopy-gen/ │ │ │ │ │ ├── generators/ │ │ │ │ │ │ └── deepcopy.go │ │ │ │ │ ├── main.go │ │ │ │ │ └── output_tests/ │ │ │ │ │ ├── aliases/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── zz_generated.go │ │ │ │ │ ├── builtins/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── zz_generated.go │ │ │ │ │ ├── interface_fuzzer.go │ │ │ │ │ ├── interfaces/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── zz_generated.go │ │ │ │ │ ├── maps/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── zz_generated.go │ │ │ │ │ ├── otherpkg/ │ │ │ │ │ │ └── interfaces.go │ │ │ │ │ ├── pointer/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── zz_generated.go │ │ │ │ │ ├── reflect_deepcopy.go │ │ │ │ │ ├── slices/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── zz_generated.go │ │ │ │ │ ├── structs/ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ └── zz_generated.go │ │ │ │ │ ├── value_fuzzer.go │ │ │ │ │ └── wholepkg/ │ │ │ │ │ ├── a.go │ │ │ │ │ ├── b.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── interfaces.go │ │ │ │ │ └── zz_generated.go │ │ │ │ ├── defaulter-gen/ │ │ │ │ │ ├── _output_tests/ │ │ │ │ │ │ ├── empty/ │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── type.go │ │ │ │ │ │ │ └── zz_generated.go │ │ │ │ │ │ ├── pointer/ │ │ │ │ │ │ │ ├── defaults.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── type.go │ │ │ │ │ │ │ └── zz_generated.go │ │ │ │ │ │ ├── slices/ │ │ │ │ │ │ │ ├── defaults.go │ │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ │ ├── type.go │ │ │ │ │ │ │ └── zz_generated.go │ │ │ │ │ │ └── wholepkg/ │ │ │ │ │ │ ├── defaults.go │ │ │ │ │ │ ├── doc.go │ │ │ │ │ │ ├── type.go │ │ │ │ │ │ └── zz_generated.go │ │ │ │ │ ├── generators/ │ │ │ │ │ │ └── defaulter.go │ │ │ │ │ └── main.go │ │ │ │ ├── import-boss/ │ │ │ │ │ ├── generators/ │ │ │ │ │ │ └── import_restrict.go │ │ │ │ │ └── main.go │ │ │ │ └── set-gen/ │ │ │ │ ├── generators/ │ │ │ │ │ ├── sets.go │ │ │ │ │ └── tags.go │ │ │ │ ├── main.go │ │ │ │ └── sets/ │ │ │ │ ├── byte.go │ │ │ │ ├── doc.go │ │ │ │ ├── empty.go │ │ │ │ ├── int.go │ │ │ │ ├── int64.go │ │ │ │ ├── string.go │ │ │ │ └── types/ │ │ │ │ └── types.go │ │ │ ├── generator/ │ │ │ │ ├── default_generator.go │ │ │ │ ├── default_package.go │ │ │ │ ├── doc.go │ │ │ │ ├── error_tracker.go │ │ │ │ ├── execute.go │ │ │ │ ├── generator.go │ │ │ │ ├── import_tracker.go │ │ │ │ └── snippet_writer.go │ │ │ ├── namer/ │ │ │ │ ├── doc.go │ │ │ │ ├── import_tracker.go │ │ │ │ ├── namer.go │ │ │ │ ├── order.go │ │ │ │ └── plural_namer.go │ │ │ ├── parser/ │ │ │ │ ├── doc.go │ │ │ │ └── parse.go │ │ │ ├── testdata/ │ │ │ │ └── a/ │ │ │ │ ├── a.go │ │ │ │ └── b/ │ │ │ │ └── b.go │ │ │ └── types/ │ │ │ ├── comments.go │ │ │ ├── doc.go │ │ │ ├── flatten.go │ │ │ └── types.go │ │ ├── klog/ │ │ │ ├── LICENSE │ │ │ ├── klog.go │ │ │ └── klog_file.go │ │ └── kube-openapi/ │ │ ├── LICENSE │ │ └── pkg/ │ │ └── util/ │ │ └── proto/ │ │ ├── doc.go │ │ ├── document.go │ │ └── openapi.go │ ├── knative.dev/ │ │ └── pkg/ │ │ ├── LICENSE │ │ ├── apis/ │ │ │ ├── condition_set.go │ │ │ ├── condition_types.go │ │ │ ├── contexts.go │ │ │ ├── deprecated.go │ │ │ ├── doc.go │ │ │ ├── duck/ │ │ │ │ ├── cached.go │ │ │ │ ├── doc.go │ │ │ │ ├── enqueue.go │ │ │ │ ├── interface.go │ │ │ │ ├── patch.go │ │ │ │ ├── proxy.go │ │ │ │ ├── register.go │ │ │ │ ├── typed.go │ │ │ │ ├── unstructured.go │ │ │ │ ├── v1alpha1/ │ │ │ │ │ ├── addressable_types.go │ │ │ │ │ ├── condition_set.go │ │ │ │ │ ├── conditions_types.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── legacy_targetable_types.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── retired_targetable_types.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ ├── v1beta1/ │ │ │ │ │ ├── addressable_types.go │ │ │ │ │ ├── doc.go │ │ │ │ │ ├── register.go │ │ │ │ │ ├── status_types.go │ │ │ │ │ └── zz_generated.deepcopy.go │ │ │ │ └── verify.go │ │ │ ├── field_error.go │ │ │ ├── interfaces.go │ │ │ ├── kind2resource.go │ │ │ ├── metadata_validation.go │ │ │ ├── url.go │ │ │ ├── volatile_time.go │ │ │ └── zz_generated.deepcopy.go │ │ ├── changeset/ │ │ │ ├── commit.go │ │ │ └── doc.go │ │ ├── configmap/ │ │ │ ├── doc.go │ │ │ ├── filter.go │ │ │ ├── informed_watcher.go │ │ │ ├── load.go │ │ │ ├── manual_watcher.go │ │ │ ├── static_watcher.go │ │ │ ├── store.go │ │ │ └── watcher.go │ │ ├── kmeta/ │ │ │ ├── accessor.go │ │ │ ├── doc.go │ │ │ ├── labels.go │ │ │ ├── names.go │ │ │ └── owner_references.go │ │ ├── kmp/ │ │ │ ├── diff.go │ │ │ ├── doc.go │ │ │ └── reporters.go │ │ ├── logging/ │ │ │ ├── config.go │ │ │ ├── logger.go │ │ │ ├── logkey/ │ │ │ │ └── constants.go │ │ │ └── zz_generated.deepcopy.go │ │ ├── ptr/ │ │ │ ├── doc.go │ │ │ └── ptr.go │ │ ├── signals/ │ │ │ ├── signal.go │ │ │ ├── signal_posix.go │ │ │ └── signal_windows.go │ │ ├── test/ │ │ │ ├── cleanup.go │ │ │ ├── clients.go │ │ │ ├── crd.go │ │ │ ├── e2e_flags.go │ │ │ ├── ingress/ │ │ │ │ └── ingress.go │ │ │ ├── kube_checks.go │ │ │ ├── logging/ │ │ │ │ └── logging.go │ │ │ ├── monitoring/ │ │ │ │ ├── doc.go │ │ │ │ └── monitoring.go │ │ │ ├── request.go │ │ │ ├── spoof/ │ │ │ │ ├── error_checks.go │ │ │ │ └── spoof.go │ │ │ └── zipkin/ │ │ │ ├── doc.go │ │ │ └── util.go │ │ └── webhook/ │ │ ├── certs.go │ │ ├── user_info.go │ │ └── webhook.go │ ├── sigs.k8s.io/ │ │ ├── controller-runtime/ │ │ │ ├── LICENSE │ │ │ └── pkg/ │ │ │ ├── cache/ │ │ │ │ ├── cache.go │ │ │ │ ├── informer_cache.go │ │ │ │ └── internal/ │ │ │ │ ├── cache_reader.go │ │ │ │ ├── deleg_map.go │ │ │ │ └── informers_map.go │ │ │ ├── client/ │ │ │ │ ├── apiutil/ │ │ │ │ │ └── apimachinery.go │ │ │ │ ├── client.go │ │ │ │ ├── client_cache.go │ │ │ │ ├── config/ │ │ │ │ │ ├── config.go │ │ │ │ │ └── doc.go │ │ │ │ ├── fake/ │ │ │ │ │ ├── client.go │ │ │ │ │ └── doc.go │ │ │ │ ├── interfaces.go │ │ │ │ ├── split.go │ │ │ │ ├── typed_client.go │ │ │ │ └── unstructured_client.go │ │ │ ├── controller/ │ │ │ │ ├── controller.go │ │ │ │ ├── controllerutil/ │ │ │ │ │ ├── controllerutil.go │ │ │ │ │ └── doc.go │ │ │ │ └── doc.go │ │ │ ├── event/ │ │ │ │ ├── doc.go │ │ │ │ └── event.go │ │ │ ├── handler/ │ │ │ │ ├── doc.go │ │ │ │ ├── enqueue.go │ │ │ │ ├── enqueue_mapped.go │ │ │ │ ├── enqueue_owner.go │ │ │ │ └── eventhandler.go │ │ │ ├── internal/ │ │ │ │ ├── controller/ │ │ │ │ │ ├── controller.go │ │ │ │ │ └── metrics/ │ │ │ │ │ └── metrics.go │ │ │ │ └── recorder/ │ │ │ │ └── recorder.go │ │ │ ├── leaderelection/ │ │ │ │ ├── doc.go │ │ │ │ └── leader_election.go │ │ │ ├── manager/ │ │ │ │ ├── doc.go │ │ │ │ ├── internal.go │ │ │ │ ├── manager.go │ │ │ │ └── testutil.go │ │ │ ├── metrics/ │ │ │ │ ├── doc.go │ │ │ │ ├── listener.go │ │ │ │ └── registry.go │ │ │ ├── patch/ │ │ │ │ ├── doc.go │ │ │ │ └── patch.go │ │ │ ├── predicate/ │ │ │ │ ├── doc.go │ │ │ │ └── predicate.go │ │ │ ├── reconcile/ │ │ │ │ ├── doc.go │ │ │ │ └── reconcile.go │ │ │ ├── recorder/ │ │ │ │ └── recorder.go │ │ │ ├── runtime/ │ │ │ │ ├── inject/ │ │ │ │ │ ├── doc.go │ │ │ │ │ └── inject.go │ │ │ │ ├── log/ │ │ │ │ │ ├── deleg.go │ │ │ │ │ ├── kube_helpers.go │ │ │ │ │ ├── log.go │ │ │ │ │ └── null.go │ │ │ │ ├── scheme/ │ │ │ │ │ └── scheme.go │ │ │ │ └── signals/ │ │ │ │ ├── doc.go │ │ │ │ ├── signal.go │ │ │ │ ├── signal_posix.go │ │ │ │ └── signal_windows.go │ │ │ ├── source/ │ │ │ │ ├── doc.go │ │ │ │ ├── internal/ │ │ │ │ │ └── eventsource.go │ │ │ │ └── source.go │ │ │ └── webhook/ │ │ │ ├── admission/ │ │ │ │ ├── decode.go │ │ │ │ ├── doc.go │ │ │ │ ├── http.go │ │ │ │ ├── response.go │ │ │ │ ├── types/ │ │ │ │ │ └── types.go │ │ │ │ └── webhook.go │ │ │ ├── internal/ │ │ │ │ └── metrics/ │ │ │ │ └── metrics.go │ │ │ └── types/ │ │ │ └── webhook.go │ │ ├── controller-tools/ │ │ │ ├── LICENSE │ │ │ ├── cmd/ │ │ │ │ └── controller-gen/ │ │ │ │ └── main.go │ │ │ └── pkg/ │ │ │ ├── crd/ │ │ │ │ ├── generator/ │ │ │ │ │ └── generator.go │ │ │ │ └── util/ │ │ │ │ └── util.go │ │ │ ├── generate/ │ │ │ │ └── rbac/ │ │ │ │ ├── manifests.go │ │ │ │ └── parser.go │ │ │ ├── internal/ │ │ │ │ └── codegen/ │ │ │ │ ├── parse/ │ │ │ │ │ ├── apis.go │ │ │ │ │ ├── context.go │ │ │ │ │ ├── crd.go │ │ │ │ │ ├── index.go │ │ │ │ │ ├── parser.go │ │ │ │ │ └── util.go │ │ │ │ └── types.go │ │ │ └── util/ │ │ │ └── util.go │ │ └── testing_frameworks/ │ │ ├── LICENSE │ │ └── integration/ │ │ ├── addr/ │ │ │ └── manager.go │ │ ├── apiserver.go │ │ ├── control_plane.go │ │ ├── doc.go │ │ ├── etcd.go │ │ ├── internal/ │ │ │ ├── apiserver.go │ │ │ ├── arguments.go │ │ │ ├── bin_path_finder.go │ │ │ ├── etcd.go │ │ │ └── process.go │ │ └── kubectl.go │ └── stathat.com/ │ └── c/ │ └── consistent/ │ ├── LICENSE │ ├── README.md │ ├── consistent.go │ ├── consistent_test.go │ └── example_test.go ├── rocketmq-logstash-integration/ │ ├── LICENSE │ ├── NOTICE │ ├── README.md │ ├── rocketmq-logstash-input/ │ │ ├── .gitignore │ │ ├── LICENSE │ │ ├── README.md │ │ ├── VERSION │ │ ├── build.gradle │ │ ├── gradle/ │ │ │ └── wrapper/ │ │ │ ├── gradle-wrapper.jar │ │ │ └── gradle-wrapper.properties │ │ ├── gradlew │ │ ├── gradlew.bat │ │ └── src/ │ │ └── main/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── logstashplugin/ │ │ └── input/ │ │ └── RocketMQ.java │ └── rocketmq-logstash-output/ │ ├── .gitignore │ ├── LICENSE │ ├── README.md │ ├── VERSION │ ├── build.gradle │ ├── gradle/ │ │ └── wrapper/ │ │ ├── gradle-wrapper.jar │ │ └── gradle-wrapper.properties │ ├── gradlew │ ├── gradlew.bat │ └── src/ │ ├── main/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── logstashplugin/ │ │ └── output/ │ │ └── RocketMQ.java │ └── test/ │ └── java/ │ └── org/ │ └── apache/ │ └── rocketmq/ │ └── logstashplugin/ │ └── output/ │ └── RocketMQTest.java ├── rocketmq-mysql/ │ ├── .gitignore │ ├── LICENSE │ ├── LICENSE-BIN │ ├── NOTICE │ ├── NOTICE-BIN │ ├── README.md │ ├── pom.xml │ ├── src/ │ │ ├── main/ │ │ │ ├── assembly/ │ │ │ │ ├── assembly.xml │ │ │ │ └── scripts/ │ │ │ │ ├── start.sh │ │ │ │ └── stop.sh │ │ │ ├── java/ │ │ │ │ └── org/ │ │ │ │ └── apache/ │ │ │ │ └── rocketmq/ │ │ │ │ └── mysql/ │ │ │ │ ├── Config.java │ │ │ │ ├── Replicator.java │ │ │ │ ├── binlog/ │ │ │ │ │ ├── DataRow.java │ │ │ │ │ ├── EventListener.java │ │ │ │ │ ├── EventProcessor.java │ │ │ │ │ └── Transaction.java │ │ │ │ ├── position/ │ │ │ │ │ ├── BinlogPosition.java │ │ │ │ │ ├── BinlogPositionLogThread.java │ │ │ │ │ └── BinlogPositionManager.java │ │ │ │ ├── productor/ │ │ │ │ │ └── RocketMQProducer.java │ │ │ │ └── schema/ │ │ │ │ ├── Database.java │ │ │ │ ├── Schema.java │ │ │ │ ├── Table.java │ │ │ │ └── column/ │ │ │ │ ├── BigIntColumnParser.java │ │ │ │ ├── ColumnParser.java │ │ │ │ ├── DateTimeColumnParser.java │ │ │ │ ├── DefaultColumnParser.java │ │ │ │ ├── EnumColumnParser.java │ │ │ │ ├── IntColumnParser.java │ │ │ │ ├── SetColumnParser.java │ │ │ │ ├── StringColumnParser.java │ │ │ │ ├── TimeColumnParser.java │ │ │ │ └── YearColumnParser.java │ │ │ └── resources/ │ │ │ ├── logback.xml │ │ │ └── rocketmq_mysql.conf │ │ └── test/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── mysql/ │ │ ├── BigIntColumnParserTest.java │ │ ├── EnumColumnParserTest.java │ │ ├── IntColumnParserTest.java │ │ └── SetColumnParserTest.java │ └── style/ │ ├── copyright/ │ │ ├── Apache.xml │ │ └── profiles_settings.xml │ ├── rmq_checkstyle.xml │ └── rmq_codeStyle.xml ├── rocketmq-redis/ │ ├── .gitignore │ ├── CHANGELOG.md │ ├── CONTRIBUTING.md │ ├── INTEGRATION-TEST │ ├── LICENSE │ ├── LICENSE-BIN │ ├── NOTICE │ ├── NOTICE-BIN │ ├── README.md │ ├── pom.xml │ ├── src/ │ │ ├── main/ │ │ │ ├── assembly/ │ │ │ │ ├── assembly.xml │ │ │ │ └── scripts/ │ │ │ │ ├── start.sh │ │ │ │ └── stop.sh │ │ │ ├── java/ │ │ │ │ └── org/ │ │ │ │ └── apache/ │ │ │ │ └── rocketmq/ │ │ │ │ └── redis/ │ │ │ │ └── replicator/ │ │ │ │ ├── RocketMQRedisReplicator.java │ │ │ │ ├── conf/ │ │ │ │ │ ├── Configure.java │ │ │ │ │ ├── ConfigureException.java │ │ │ │ │ └── ReplicatorConstants.java │ │ │ │ └── mq/ │ │ │ │ ├── EventListener.java │ │ │ │ ├── KryoEventSerializer.java │ │ │ │ ├── RocketMQRedisConsumer.java │ │ │ │ ├── RocketMQRedisProducer.java │ │ │ │ └── Serializer.java │ │ │ └── resources/ │ │ │ ├── logback.xml │ │ │ └── replicator.conf │ │ └── test/ │ │ ├── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── redis/ │ │ │ └── replicator/ │ │ │ ├── BaseConf.java │ │ │ ├── IntegrationTestBase.java │ │ │ ├── RocketMQRedisReplicatorTest.java │ │ │ └── mq/ │ │ │ └── KryoEventSerializerTest.java │ │ └── resources/ │ │ ├── dumpV7.rdb │ │ └── log4j2.xml │ └── style/ │ ├── copyright/ │ │ ├── Apache.xml │ │ └── profiles_settings.xml │ ├── rmq_checkstyle.xml │ └── rmq_codeStyle.xml ├── rocketmq-rocksdb/ │ ├── LICENSE │ ├── NOTICE │ ├── README.md │ ├── RemoveConsumeQueueCompactionFilter.java │ ├── build-win.bat │ ├── pom.xml │ ├── remove_consumequeue_compactionfilter.cc │ ├── remove_consumequeue_compactionfilter.h │ ├── remove_consumequeue_compactionfilterjni.cc │ └── thirdparty.inc ├── rocketmq-sentinel/ │ ├── LICENSE │ ├── README.md │ ├── pom.xml │ └── src/ │ └── main/ │ └── java/ │ └── com/ │ └── alibaba/ │ └── csp/ │ └── sentinel/ │ └── demo/ │ └── rocketmq/ │ ├── Constants.java │ ├── PullConsumerDemo.java │ └── SyncProducer.java ├── rocketmq-serializer/ │ ├── README.md │ ├── rocketmq-serializer-avro/ │ │ ├── pom.xml │ │ └── src/ │ │ ├── main/ │ │ │ └── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── serializer/ │ │ │ └── avro/ │ │ │ ├── AvroUtils.java │ │ │ ├── DefaultSchemaRegistry.java │ │ │ ├── RocketMQAvroDeserializer.java │ │ │ ├── RocketMQAvroSerializer.java │ │ │ ├── RocketMQAvroSpecifiedDeserializer.java │ │ │ ├── RocketMQAvroSpecifiedSerializer.java │ │ │ └── SchemaRegistry.java │ │ └── test/ │ │ ├── avro/ │ │ │ └── user.avsc │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── serializer/ │ │ └── avro/ │ │ ├── RocketMQAvroSerializerTest.java │ │ ├── RocketMQAvroSpecifiedSerializerTest.java │ │ └── User.java │ ├── rocketmq-serializer-core/ │ │ ├── pom.xml │ │ └── src/ │ │ ├── main/ │ │ │ └── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── serializer/ │ │ │ ├── Messages.java │ │ │ ├── RocketMQDeserializer.java │ │ │ ├── RocketMQSerializer.java │ │ │ └── impl/ │ │ │ ├── RocketMQStringDeserializer.java │ │ │ └── RocketMQStringSerializer.java │ │ └── test/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── serializer/ │ │ └── impl/ │ │ └── RocketMQStringSerializerTest.java │ ├── rocketmq-serializer-examples/ │ │ ├── pom.xml │ │ └── src/ │ │ └── main/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── serializer/ │ │ ├── JsonConsumer.java │ │ ├── JsonProducer.java │ │ ├── RocketMQLocalCluster.java │ │ ├── SimpleConsumer.java │ │ ├── SimpleProducer.java │ │ └── User.java │ ├── rocketmq-serializer-json/ │ │ ├── pom.xml │ │ └── src/ │ │ ├── main/ │ │ │ └── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── serializer/ │ │ │ └── json/ │ │ │ ├── RocketMQJsonDeserializer.java │ │ │ └── RocketMQJsonSerializer.java │ │ └── test/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── serializer/ │ │ └── json/ │ │ ├── RocketMQJsonSerializerTest.java │ │ └── User.java │ └── style/ │ ├── copyright/ │ │ ├── Apache.xml │ │ └── profiles_settings.xml │ ├── rmq_checkstyle.xml │ └── rmq_codeStyle.xml ├── rocketmq-spark/ │ ├── LICENSE │ ├── NOTICE │ ├── README.md │ ├── pom.xml │ ├── spark-streaming-rocketmq.md │ ├── spark-structured-streaming-rocketmq.md │ ├── src/ │ │ ├── main/ │ │ │ ├── java/ │ │ │ │ └── org/ │ │ │ │ └── apache/ │ │ │ │ └── rocketmq/ │ │ │ │ └── spark/ │ │ │ │ ├── OffsetCommitCallback.java │ │ │ │ ├── RocketMQConfig.java │ │ │ │ ├── TopicQueueId.java │ │ │ │ └── streaming/ │ │ │ │ ├── DefaultMessageRetryManager.java │ │ │ │ ├── MQPullConsumerProvider.java │ │ │ │ ├── MQPullConsumerProviderFactory.java │ │ │ │ ├── MessageRetryManager.java │ │ │ │ ├── MessageSet.java │ │ │ │ ├── ReliableRocketMQReceiver.java │ │ │ │ ├── RocketMQReceiver.java │ │ │ │ ├── SimpleMQPullConsumerProvider.java │ │ │ │ └── SimpleMQPullConsumerProviderFactory.java │ │ │ ├── resources/ │ │ │ │ └── META-INF/ │ │ │ │ └── services/ │ │ │ │ └── org.apache.rocketmq.spark.streaming.MQPullConsumerProviderFactory │ │ │ └── scala/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ ├── rocketmq/ │ │ │ │ └── spark/ │ │ │ │ ├── CachedMQConsumer.scala │ │ │ │ ├── ConsumerProviderFactory.scala │ │ │ │ ├── ConsumerStrategy.scala │ │ │ │ ├── LocationStrategy.scala │ │ │ │ ├── Logging.scala │ │ │ │ ├── OffsetRange.scala │ │ │ │ ├── RocketMqRDDPartition.scala │ │ │ │ └── RocketMqUtils.scala │ │ │ └── spark/ │ │ │ ├── sql/ │ │ │ │ └── rocketmq/ │ │ │ │ ├── CachedRocketMQConsumer.scala │ │ │ │ ├── CachedRocketMQProducer.scala │ │ │ │ ├── JsonUtils.scala │ │ │ │ ├── RocketMQConf.scala │ │ │ │ ├── RocketMQOffsetRangeLimit.scala │ │ │ │ ├── RocketMQOffsetReader.scala │ │ │ │ ├── RocketMQRelation.scala │ │ │ │ ├── RocketMQSink.scala │ │ │ │ ├── RocketMQSource.scala │ │ │ │ ├── RocketMQSourceOffset.scala │ │ │ │ ├── RocketMQSourceProvider.scala │ │ │ │ ├── RocketMQSourceRDD.scala │ │ │ │ ├── RocketMQSqlUtils.scala │ │ │ │ ├── RocketMQWriteTask.scala │ │ │ │ └── RocketMQWriter.scala │ │ │ └── streaming/ │ │ │ ├── MQPullInputDStream.scala │ │ │ └── RocketMqRDD.scala │ │ └── test/ │ │ ├── java/ │ │ │ └── org/ │ │ │ └── apache/ │ │ │ └── rocketmq/ │ │ │ └── spark/ │ │ │ ├── RocketMQServerMock.java │ │ │ ├── sql/ │ │ │ │ └── RocketMQDataSourceTest.java │ │ │ └── streaming/ │ │ │ ├── MessageRetryManagerTest.java │ │ │ ├── ReliableRocketMQReceiverTest.java │ │ │ ├── RocketMQReceiverTest.java │ │ │ └── RocketMqUtilsTest.java │ │ └── resources/ │ │ └── log4j.properties │ └── style/ │ ├── copyright/ │ │ ├── Apache.xml │ │ └── profiles_settings.xml │ ├── rmq_checkstyle.xml │ └── rmq_codeStyle.xml ├── rocketmq-tieredstore-s3/ │ ├── README.md │ ├── pom.xml │ ├── src/ │ │ └── main/ │ │ └── java/ │ │ └── org/ │ │ └── apache/ │ │ └── rocketmq/ │ │ └── tieredstore/ │ │ └── s3/ │ │ ├── S3FileLock.java │ │ ├── S3FileSegment.java │ │ ├── TieredS3Storage.java │ │ ├── constants/ │ │ │ └── S3Constants.java │ │ ├── metadata/ │ │ │ ├── S3ChunkMetadata.java │ │ │ └── S3FileSegmentMetadata.java │ │ ├── object/ │ │ │ ├── AbstractS3Storage.java │ │ │ ├── AwsS3Storage.java │ │ │ ├── S3Storage.java │ │ │ ├── S3URI.java │ │ │ └── bytebuf/ │ │ │ ├── ByteBufAlloc.java │ │ │ └── ByteBufAllocPolicy.java │ │ └── util/ │ │ └── S3PathUtils.java │ └── style/ │ ├── copyright/ │ │ ├── Apache.xml │ │ └── profiles_settings.xml │ ├── rmq_checkstyle.xml │ └── rmq_codeStyle.xml └── tools/ └── chrome-plugin-rocketmq-helper/ ├── README.md ├── js/ │ ├── content-script.js │ └── jquery.js ├── manifest.json ├── popup.html └── popup.js ================================================ FILE CONTENTS ================================================ ================================================ FILE: .github/ISSUE_TEMPLATE.md ================================================ The issue tracker is **ONLY** used for bug report and feature request. Any question or RocketMQ proposal please use our [mailing lists](http://rocketmq.apache.org/about/contact/). **BUG REPORT** 1. Please describe the issue you observed: - What did you do (The steps to reproduce)? - What did you expect to see? - What did you see instead? 2. Please tell us about your environment: 3. Other information (e.g. detailed explanation, logs, related issues, suggestions how to fix, etc): **FEATURE REQUEST** 1. Please describe the feature you are requesting. 2. Provide any additional detail on your proposed use case for this feature. 2. Indicate the importance of this issue to you (blocker, must-have, should-have, nice-to-have). Are you currently using any workarounds to address this issue? 4. If there are some sub-tasks using -[] for each subtask and create a corresponding issue to map to the sub task: - [sub-task1-issue-number](example_sub_issue1_link_here): sub-task1 description here, - [sub-task2-issue-number](example_sub_issue2_link_here): sub-task2 description here, - ... ================================================ FILE: .github/PULL_REQUEST_TEMPLATE.md ================================================ ## What is the purpose of the change XXXXX ## Brief changelog XX ## Verifying this change XXXX Follow this checklist to help us incorporate your contribution quickly and easily. Notice, `it would be helpful if you could finish the following 5 checklist(the last one is not necessary)before request the community to review your PR`. - [x] Make sure there is a [Github issue](https://github.com/apache/rocketmq/issues) filed for the change (usually before you start working on it). Trivial changes like typos do not require a Github issue. Your pull request should address just this issue, without pulling in other changes - one PR resolves one issue. - [x] Format the pull request title like `[ISSUE #123] Fix UnknownException when host config not exist`. Each commit in the pull request should have a meaningful subject line and body. - [x] Write a pull request description that is detailed enough to understand what the pull request does, how, and why. - [x] Write necessary unit-test(over 80% coverage) to verify your logic correction, more mock a little better when cross module dependency exist. If the new feature or significant change is committed, please remember to add integration-test in [test module](https://github.com/apache/rocketmq/tree/master/test). - [x] Run `mvn -B clean apache-rat:check findbugs:findbugs checkstyle:checkstyle` to make sure basic checks pass. Run `mvn clean install -DskipITs` to make sure unit-test pass. Run `mvn clean test-compile failsafe:integration-test` to make sure integration-test pass. - [ ] If this contribution is large, please file an [Apache Individual Contributor License Agreement](http://www.apache.org/licenses/#clas). ================================================ FILE: .gitignore ================================================ .idea .classpath .project .settings/ target/ *.log* *.iml .idea/ *.versionsBackup !NOTICE-BIN !LICENSE-BIN .DS_Store .vscode # .NET .vs [Bb]in/ [Oo]bj/ ================================================ FILE: .travis.yml ================================================ dist: trusty notifications: email: recipients: - dev@rocketmq.apache.org on_success: change on_failure: always language: java jdk: - oraclejdk8 - oraclejdk9 - oraclejdk11 - openjdk8 branches: only: - master env: - TEST_DIR=rocketmq-connect script: "cd $TEST_DIR && mvn clean package" ================================================ FILE: README.md ================================================ # [Apache RocketMQ](https://github.com/apache/rocketmq) Community Projects Home There are many of the Apache RocketMQ external projects, which is born from [Apache RocketMQ Improvement Proposal](https://github.com/apache/rocketmq/wiki/RocketMQ-Improvement-Proposal) and contributed and maintained by community. The PMC will lean towards developer community support, to help discovery and initial steps towards incubation in the external repository. Incubator Projects could graduate if they meet the following requirements. * Require 3+1 vote from the PMC. * Used successfully in production by at least three independent end users which, in the PMC judgement, are of adequate quality and scope. * Have a healthy number of committers. # Docs [User Guide for Connect 中文版](./docs/connect/cn/README.md) # Graduated Projects ### [RocketMQ Client CPP](https://github.com/apache/rocketmq-client-cpp) ### [RocketMQ Client Python](https://github.com/apache/rocketmq-client-python) ### [RocketMQ Spring](https://github.com/apache/rocketmq-spring) ### [RocketMQ Client Go](https://github.com/apache/rocketmq-client-go) # Incubator Projects ## [RocketMQ Dashboard](https://github.com/apache/rocketmq-dashboard) **Notice**: Console has renamed to dashboard and transfered the new repo, it will graduate in the near future, and welcome you to fill in the user due diligence. ## [RocketMQ MQTT](https://github.com/apache/rocketmq-mqtt) A new MQTT protocol architecture model, based on which RocketMQ can better support messages from terminals such as IoT devices and Mobile APP. Based on the RocketMQ message unified storage engine, it supports both MQTT terminal and server message sending and receiving. ## [RocketMQ-Flink](https://github.com/apache/rocketmq-flink) **Notice**: The project has transfered the new repo and will be removed from this repo, it will graduate in the near future, and welcome you to fill in the user due diligence. ## [RocketMQ Streams](https://github.com/apache/rocketmq-streams) ## [RocketMQ Operator](https://github.com/apache/rocketmq-operator) Deploys RocketMQ on Kubernetes. it is built using the Operator SDK, which is part of the Operator Framework and hosted on [OperatorHub](https://operatorhub.io/operator/rocketmq-operator) ## [RocketMQ Client Nodejs](https://github.com/apache/rocketmq-client-nodejs) ## [RocketMQ-Docker](https://github.com/apache/rocketmq-docker) Provides Dockerfile and bash scripts for building and running docker image. ## [RocketMQ-Exporter](https://github.com/apache/rocketmq-exporter) Exports metrics from RocketMQ servers for consumption by Prometheus. ## [RocketMQ-Connect](https://github.com/apache/rocketmq-connect) RocketMQ connector, connect everything. ## RocketMQ-Flume Flume RocketMQ source and sink implementation. ## RocketMQ-Spark Integration of Apache Spark and Apache RocketMQ. Both push & pull consumers are provided. For more details please refer to [README](https://github.com/apache/rocketmq-externals/tree/master/rocketmq-spark). ## RocketMQ-JMS RocketMQ's JMS 1.1 spec. implementation. ## RocketMQ-MySQL This project is a data replicator between MySQL and other systems. For more details please refer to [README](https://github.com/apache/rocketmq-externals/tree/master/rocketmq-mysql). ## Others [RocketMQ-OpenTelemetry](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/rocketmq), [RocketMQ-Ignite](https://github.com/apache/ignite-extensions/tree/master/modules/rocketmq-ext) and [RocketMQ-Storm](https://github.com/apache/storm/tree/master/external/storm-rocketmq) integration can be found in those repositories. ## Contribution We are always very happy to have contributions, whether for trivial cleanups or big new features. We want to have high quality, well documented codes for each programming language, as well as the surrounding ecosystem of integration tools that people use with RocketMQ. Nor is code the only way to contribute to the project. We strongly value documentation, integration with other project, and gladly accept improvements for these aspects. More info please refer to [How To Contribute](http://rocketmq.apache.org/docs/how-to-contribute/). ================================================ FILE: dev/merge_rocketmq_pr.py ================================================ #!/usr/bin/env python # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # # This script is a modified version of the one created by the Spark # project (https://github.com/apache/spark/blob/master/dev/merge_spark_pr.py). # Utility for creating well-formed pull request merges and pushing them to Apache. # usage: ./merge_rocketmq_pr.py (see config env vars below) # # This utility assumes you already have local a RocketMQ git folder and that you # have added remotes corresponding to both (i) the github apache RocketMQ # mirror and (ii) the apache git repo. import json import os import re import subprocess import sys import urllib2 try: import jira.client JIRA_IMPORTED = True except ImportError: JIRA_IMPORTED = False # Location of your RocketMQ git development area ROCKETMQ_HOME = os.environ.get("ROCKETMQ_HOME", os.getcwd()) # Remote name which points to the Gihub site PR_REMOTE_NAME = os.environ.get("PR_REMOTE_NAME", "apache-github") # Remote name which points to Apache git PUSH_REMOTE_NAME = os.environ.get("PUSH_REMOTE_NAME", "origin") # ASF JIRA username JIRA_USERNAME = os.environ.get("JIRA_USERNAME", "") # ASF JIRA password JIRA_PASSWORD = os.environ.get("JIRA_PASSWORD", "") # OAuth key used for issuing requests against the GitHub API. If this is not defined, then requests # will be unauthenticated. You should only need to configure this if you find yourself regularly # exceeding your IP's unauthenticated request rate limit. You can create an OAuth key at # https://github.com/settings/tokens. This script only requires the "public_repo" scope. GITHUB_OAUTH_KEY = os.environ.get("GITHUB_OAUTH_KEY") GITHUB_BASE = "https://github.com/apache/incubator-rocketmq-externals/pull" GITHUB_API_BASE = "https://api.github.com/repos/apache/incubator-rocketmq-externals" JIRA_BASE = "https://issues.apache.org/jira/browse" JIRA_API_BASE = "https://issues.apache.org/jira" # Prefix added to temporary branches BRANCH_PREFIX = "PR_TOOL" DEVELOP_BRANCH = "master" def get_json(url): try: request = urllib2.Request(url) if GITHUB_OAUTH_KEY: request.add_header('Authorization', 'token %s' % GITHUB_OAUTH_KEY) return json.load(urllib2.urlopen(request)) except urllib2.HTTPError as e: if "X-RateLimit-Remaining" in e.headers and e.headers["X-RateLimit-Remaining"] == '0': print("Exceeded the GitHub API rate limit; see the instructions in " + "dev/merge_rocketmq_pr.py to configure an OAuth token for making authenticated " + "GitHub requests.") else: print("Unable to fetch URL, exiting: %s" % url) sys.exit(-1) def fail(msg): print(msg) clean_up() sys.exit(-1) def run_cmd(cmd): print(cmd) if isinstance(cmd, list): return subprocess.check_output(cmd) else: return subprocess.check_output(cmd.split(" ")) def continue_maybe(prompt): result = raw_input("\n%s (y/n): " % prompt) if result.lower() != "y": fail("Okay, exiting") def clean_up(): print("Restoring head pointer to %s" % original_head) run_cmd("git checkout %s" % original_head) branches = run_cmd("git branch").replace(" ", "").split("\n") for branch in filter(lambda x: x.startswith(BRANCH_PREFIX), branches): print("Deleting local branch %s" % branch) run_cmd("git branch -D %s" % branch) # merge the requested PR and return the merge hash def merge_pr(pr_num, target_ref, title, body, pr_repo_desc): pr_branch_name = "%s_MERGE_PR_%s" % (BRANCH_PREFIX, pr_num) target_branch_name = "%s_MERGE_PR_%s_%s" % (BRANCH_PREFIX, pr_num, target_ref.upper()) run_cmd("git fetch %s pull/%s/head:%s" % (PR_REMOTE_NAME, pr_num, pr_branch_name)) run_cmd("git fetch %s %s:%s" % (PUSH_REMOTE_NAME, target_ref, target_branch_name)) run_cmd("git checkout %s" % target_branch_name) had_conflicts = False try: run_cmd(['git', 'merge', pr_branch_name, '--squash']) except Exception as e: msg = "Error merging: %s\nWould you like to manually fix-up this merge?" % e continue_maybe(msg) msg = "Okay, please fix any conflicts and 'git add' conflicting files... Finished?" continue_maybe(msg) had_conflicts = True commit_authors = run_cmd(['git', 'log', 'HEAD..%s' % pr_branch_name, '--pretty=format:%an <%ae>']).split("\n") distinct_authors = sorted(set(commit_authors), key=lambda x: commit_authors.count(x), reverse=True) primary_author = raw_input( "Enter primary author in the format of \"name \" [%s]: " % distinct_authors[0]) if primary_author == "": primary_author = distinct_authors[0] commits = run_cmd(['git', 'log', 'HEAD..%s' % pr_branch_name, '--pretty=format:%h [%an] %s']).split("\n\n") merge_message_flags = [] title = raw_input("Modify commit log [%s]: " % title) merge_message_flags += ["-m", title] authors = "\n".join(["Author: %s" % a for a in distinct_authors]) merge_message_flags += ["-m", authors] if had_conflicts: committer_name = run_cmd("git config --get user.name").strip() committer_email = run_cmd("git config --get user.email").strip() message = "This patch had conflicts when merged, resolved by\nCommitter: %s <%s>" % ( committer_name, committer_email) merge_message_flags += ["-m", message] # The string "Closes #%s" string is required for GitHub to correctly close the PR merge_message_flags += ["-m", "Closes #%s from %s." % (pr_num, pr_repo_desc)] run_cmd(['git', 'commit', '--author="%s"' % primary_author] + merge_message_flags) continue_maybe("Merge complete (local ref %s). Push to %s?" % ( target_branch_name, PUSH_REMOTE_NAME)) try: run_cmd('git push %s %s:%s' % (PUSH_REMOTE_NAME, target_branch_name, target_ref)) except Exception as e: clean_up() fail("Exception while pushing: %s" % e) merge_hash = run_cmd("git rev-parse %s" % target_branch_name)[:8] clean_up() print("Pull request #%s merged!" % pr_num) print("Merge hash: %s" % merge_hash) return merge_hash def cherry_pick(pr_num, merge_hash, default_branch): pick_ref = raw_input("Enter a branch name [%s]: " % default_branch) if pick_ref == "": pick_ref = default_branch pick_branch_name = "%s_PICK_PR_%s_%s" % (BRANCH_PREFIX, pr_num, pick_ref.upper()) run_cmd("git fetch %s %s:%s" % (PUSH_REMOTE_NAME, pick_ref, pick_branch_name)) run_cmd("git checkout %s" % pick_branch_name) try: run_cmd("git cherry-pick -sx %s" % merge_hash) except Exception as e: msg = "Error cherry-picking: %s\nWould you like to manually fix-up this merge?" % e continue_maybe(msg) msg = "Okay, please fix any conflicts and finish the cherry-pick. Finished?" continue_maybe(msg) continue_maybe("Pick complete (local ref %s). Push to %s?" % ( pick_branch_name, PUSH_REMOTE_NAME)) try: run_cmd('git push %s %s:%s' % (PUSH_REMOTE_NAME, pick_branch_name, pick_ref)) except Exception as e: clean_up() fail("Exception while pushing: %s" % e) pick_hash = run_cmd("git rev-parse %s" % pick_branch_name)[:8] clean_up() print("Pull request #%s picked into %s!" % (pr_num, pick_ref)) print("Pick hash: %s" % pick_hash) return pick_ref def fix_version_from_branch(branch, versions): # Note: Assumes this is a sorted (newest->oldest) list of un-released versions if branch == "master": return versions[0] else: branch_ver = branch.replace("branch-", "") return filter(lambda x: x.name.startswith(branch_ver), versions)[-1] def resolve_jira_issue(merge_branches, comment, default_jira_id=""): asf_jira = jira.client.JIRA({'server': JIRA_API_BASE}, basic_auth=(JIRA_USERNAME, JIRA_PASSWORD)) jira_id = raw_input("Enter a JIRA id [%s]: " % default_jira_id) if jira_id == "": jira_id = default_jira_id try: issue = asf_jira.issue(jira_id) except Exception as e: fail("ASF JIRA could not find %s\n%s" % (jira_id, e)) cur_status = issue.fields.status.name cur_summary = issue.fields.summary cur_assignee = issue.fields.assignee if cur_assignee is None: cur_assignee = "NOT ASSIGNED!!!" else: cur_assignee = cur_assignee.displayName if cur_status == "Resolved" or cur_status == "Closed": fail("JIRA issue %s already has status '%s'" % (jira_id, cur_status)) print("=== JIRA %s ===" % jira_id) print("summary\t\t%s\nassignee\t%s\nstatus\t\t%s\nurl\t\t%s/%s\n" % (cur_summary, cur_assignee, cur_status, JIRA_BASE, jira_id)) versions = asf_jira.project_versions("ROCKETMQ") versions = sorted(versions, key=lambda x: x.name, reverse=True) versions = filter(lambda x: x.raw['released'] is False, versions) # Consider only x.y.z versions versions = filter(lambda x: re.match('\d+\.\d+\.\d+', x.name), versions) default_fix_versions = map(lambda x: fix_version_from_branch(x, versions).name, merge_branches) for v in default_fix_versions: # Handles the case where we have forked a release branch but not yet made the release. # In this case, if the PR is committed to the master branch and the release branch, we # only consider the release branch to be the fix version. E.g. it is not valid to have # both 1.1.0 and 1.0.0 as fix versions. (major, minor, patch) = v.split(".") if patch == "0": previous = "%s.%s.%s" % (major, int(minor) - 1, 0) if previous in default_fix_versions: default_fix_versions = filter(lambda x: x != v, default_fix_versions) default_fix_versions = ",".join(default_fix_versions) fix_versions = raw_input("Enter comma-separated fix version(s) [%s]: " % default_fix_versions) if fix_versions == "": fix_versions = default_fix_versions fix_versions = fix_versions.replace(" ", "").split(",") def get_version_json(version_str): return filter(lambda v: v.name == version_str, versions)[0].raw jira_fix_versions = map(lambda v: get_version_json(v), fix_versions) resolve = filter(lambda a: a['name'] == "Resolve Issue", asf_jira.transitions(jira_id))[0] resolution = filter(lambda r: r.raw['name'] == "Fixed", asf_jira.resolutions())[0] asf_jira.transition_issue( jira_id, resolve["id"], fixVersions=jira_fix_versions, comment=comment, resolution={'id': resolution.raw['id']}) print("Successfully resolved %s with fixVersions=%s!" % (jira_id, fix_versions)) def resolve_jira_issues(title, merge_branches, comment): jira_ids = re.findall("ROCKETMQ-[0-9]{4,5}", title) if len(jira_ids) == 0: resolve_jira_issue(merge_branches, comment) for jira_id in jira_ids: resolve_jira_issue(merge_branches, comment, jira_id) def standardize_jira_ref(text): """ Standardize the [ROCKETMQ-XXXXX] [MODULE] prefix Converts "[ROCKETMQ-XXX][mllib] Issue", "[MLLib] ROCKETMQ-XXX. Issue" or "ROCKETMQ XXX [MLLIB]: Issue" to "[ROCKETMQ-XXX][MLLIB] Issue" """ jira_refs = [] components = [] # If the string is compliant, no need to process any further if (re.search(r'^\[ROCKETMQ-[0-9]{3,6}\](\[[A-Z0-9_\s,]+\] )+\S+', text)): return text # Extract JIRA ref(s): pattern = re.compile(r'(ROCKETMQ[-\s]*[0-9]{3,6})+', re.IGNORECASE) for ref in pattern.findall(text): # Add brackets, replace spaces with a dash, & convert to uppercase jira_refs.append('[' + re.sub(r'\s+', '-', ref.upper()) + ']') text = text.replace(ref, '') # Extract rocketmq component(s): # Look for alphanumeric chars, spaces, dashes, periods, and/or commas pattern = re.compile(r'(\[[\w\s,-\.]+\])', re.IGNORECASE) for component in pattern.findall(text): components.append(component.upper()) text = text.replace(component, '') # Cleanup any remaining symbols: pattern = re.compile(r'^\W+(.*)', re.IGNORECASE) if (pattern.search(text) is not None): text = pattern.search(text).groups()[0] # Assemble full text (JIRA ref(s), module(s), remaining text) clean_text = ''.join(jira_refs).strip() + ''.join(components).strip() + " " + text.strip() # Replace multiple spaces with a single space, e.g. if no jira refs and/or components were # included clean_text = re.sub(r'\s+', ' ', clean_text.strip()) return clean_text def get_current_ref(): ref = run_cmd("git rev-parse --abbrev-ref HEAD").strip() if ref == 'HEAD': # The current ref is a detached HEAD, so grab its SHA. return run_cmd("git rev-parse HEAD").strip() else: return ref def main(): global original_head os.chdir(ROCKETMQ_HOME) original_head = get_current_ref() latest_branch = DEVELOP_BRANCH pr_num = raw_input("Which pull request would you like to merge? (e.g. 34): ") pr = get_json("%s/pulls/%s" % (GITHUB_API_BASE, pr_num)) pr_events = get_json("%s/issues/%s/events" % (GITHUB_API_BASE, pr_num)) url = pr["url"] # Decide whether to use the modified title or not modified_title = standardize_jira_ref(pr["title"]) if modified_title != pr["title"]: print("I've re-written the title as follows to match the standard format:") print("Original: %s" % pr["title"]) print("Modified: %s" % modified_title) result = raw_input("Would you like to use the modified title? (y/n): ") if result.lower() == "y": title = modified_title print("Using modified title:") else: title = pr["title"] print("Using original title:") print(title) else: title = pr["title"] body = pr["body"] target_ref = pr["base"]["ref"] user_login = pr["user"]["login"] base_ref = pr["head"]["ref"] pr_repo_desc = "%s/%s" % (user_login, base_ref) # Merged pull requests don't appear as merged in the GitHub API; # Instead, they're closed by asfgit. merge_commits = \ [e for e in pr_events if e["actor"]["login"] == "asfgit" and e["event"] == "closed"] if merge_commits: merge_hash = merge_commits[0]["commit_id"] message = get_json("%s/commits/%s" % (GITHUB_API_BASE, merge_hash))["commit"]["message"] print("Pull request %s has already been merged, assuming you want to backport" % pr_num) commit_is_downloaded = run_cmd(['git', 'rev-parse', '--quiet', '--verify', "%s^{commit}" % merge_hash]).strip() != "" if not commit_is_downloaded: fail("Couldn't find any merge commit for #%s, you may need to update HEAD." % pr_num) print("Found commit %s:\n%s" % (merge_hash, message)) cherry_pick(pr_num, merge_hash, latest_branch) sys.exit(0) if not bool(pr["mergeable"]): msg = "Pull request %s is not mergeable in its current form.\n" % pr_num + \ "Continue? (experts only!)" continue_maybe(msg) print("\n=== Pull Request #%s ===" % pr_num) print("title\t%s\nsource\t%s\ntarget\t%s\nurl\t%s" % (title, pr_repo_desc, target_ref, url)) continue_maybe("Proceed with merging pull request #%s?" % pr_num) merged_refs = [target_ref] merge_hash = merge_pr(pr_num, target_ref, title, body, pr_repo_desc) pick_prompt = "Would you like to pick %s into another branch?" % merge_hash while raw_input("\n%s (y/n): " % pick_prompt).lower() == "y": merged_refs = merged_refs + [cherry_pick(pr_num, merge_hash, latest_branch)] if JIRA_IMPORTED: if JIRA_USERNAME and JIRA_PASSWORD: continue_maybe("Would you like to update an associated JIRA?") jira_comment = "Issue resolved by pull request %s\n[%s/%s]" % \ (pr_num, GITHUB_BASE, pr_num) resolve_jira_issues(title, merged_refs, jira_comment) else: print("JIRA_USERNAME and JIRA_PASSWORD not set") print("Exiting without trying to close the associated JIRA.") else: print("Could not find jira-python library. Run 'sudo pip install jira' to install.") print("Exiting without trying to close the associated JIRA.") if __name__ == "__main__": import doctest (failure_count, test_count) = doctest.testmod() if failure_count: exit(-1) try: main() except: clean_up() raise ================================================ FILE: docs/connect/cn/README.md ================================================ # RocketMQ Connect 中文指南 ## 文档库 * [用户手册](https://rocketmq-1.gitbook.io/rocketmq-connector/) * [快速入门](https://rocketmq-1.gitbook.io/rocketmq-connector/quick-start/qian-qi-zhun-bei) * [设计架构](https://rocketmq-1.gitbook.io/rocketmq-connector/jia-gou-she-ji) * [开发者中心](https://rocketmq-1.gitbook.io/rocketmq-connector/kai-fa-zhe-zhong-xin/mqadmin-cao-zuo-zhi-nan) * [文档贡献中心](https://github.com/rockt-cloud/openconnect-gitbook) ## 贡献说明 我们非常欢迎广大开源爱好者共同参与RocketMQ项目贡献，除了修复项目中的错误和添加新的功能外，我们也希望每种编程语言都有高质量的、有良好文档记录的代码。广大RocketMQ使用者在RocketMQ之上整个生态系统的创建和维护同样也是欢迎的。 因此代码不是对项目做出贡献的唯一方式。我们非常重视文档、与其他项目的集成，并乐于接受这些方面的改进。 ## 贡献方式 ### 1. 社区提问 加入本地社区参与讨论、文档纠错、参与rocketmq社区的技术讲座交流等都可以参与其中。 ### 2. 发现并提交bug 如果您发现项目中的任何bug，都可以在GitHub上书写issue来报告错误。 ### 3. 修复bug 您可以从多个issue中选择擅长的问题，尝试解决并提交PR ### 4. 提升性能或者增加新特性 社区一直在注重Apache RocketMQ Connect的使用反馈。如果你有一个如何改进RocketMQ Connect的想法，或者有一个对RocketMQ Connect用户有益的新特性，请在issue上详细地描述改进或新特性，并尽可能包括范围及其要求。详细信息很重要，原因如下： 它确保在实现改进或特性时满足您的需求。 它有助于评估工作和设计满足您需求的解决方案。 它允许围绕这一问题进行建设性的讨论。 如果您计划为自己提出的改进或功能做出贡献，请及时联系负责人详细交流。 我们建议在开始实施之前，首先与社区就是否需要新功能以及如何实现新功能达成共识。有些功能可能超出了项目的范围，最好及早发现。 ### 5. 帮助其他人参与其中 帮助社区的新人和使用者更深入的了解，解决别人的问题也是参与其中。 ### 6. 文档撰写与改错 文档的重要性不言而喻，参与文档工作也是贡献方式之一。 ### 7. 测试 完善的测试能够保证项目功能的完整性和稳定性，如果您能参与到测试之中，也十分欢迎。 ================================================ FILE: logappender/pom.xml ================================================ 4.0.0 org.apache.rocketmq rocketmq-logappender jar rocketmq-logappender ${project.version} 4.9.3-SNAPSHOT http://rocketmq.apache.org/ UTF-8 UTF-8 4.9.2 false true 1.8 1.8 junit junit 4.12 test org.mockito mockito-core 2.28.2 test org.slf4j slf4j-api 1.7.7 true log4j log4j 1.2.17 true org.apache.logging.log4j log4j-core 2.17.1 true ch.qos.logback logback-classic 1.2.10 true ${project.groupId} rocketmq-client ${rocketmq.version} ${project.groupId} rocketmq-namesrv ${rocketmq.version} test ch.qos.logback logback-classic ${project.groupId} rocketmq-broker ${rocketmq.version} test ch.qos.logback logback-classic ================================================ FILE: logappender/src/main/java/org/apache/rocketmq/logappender/common/ProducerInstance.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.logappender.common; import org.apache.commons.lang3.StringUtils; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.client.producer.DefaultMQProducer; import org.apache.rocketmq.client.producer.MQProducer; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; /** * Common Producer component */ public class ProducerInstance { public static final String APPENDER_TYPE = "APPENDER_TYPE"; public static final String LOG4J_APPENDER = "LOG4J_APPENDER"; public static final String LOG4J2_APPENDER = "LOG4J2_APPENDER"; public static final String LOGBACK_APPENDER = "LOGBACK_APPENDER"; public static final String DEFAULT_GROUP = "rocketmq_appender"; private ConcurrentHashMap producerMap = new ConcurrentHashMap(); private static ProducerInstance instance = new ProducerInstance(); public static ProducerInstance getProducerInstance() { return instance; } private String genKey(String nameServerAddress, String group) { return nameServerAddress + "_" + group; } public MQProducer getInstance(String nameServerAddress, String group) throws MQClientException { if (StringUtils.isBlank(group)) { group = DEFAULT_GROUP; } String genKey = genKey(nameServerAddress, group); MQProducer p = getProducerInstance().producerMap.get(genKey); if (p != null) { return p; } DefaultMQProducer defaultMQProducer = new DefaultMQProducer(group); defaultMQProducer.setNamesrvAddr(nameServerAddress); MQProducer beforeProducer = null; beforeProducer = getProducerInstance().producerMap.putIfAbsent(genKey, defaultMQProducer); if (beforeProducer != null) { return beforeProducer; } defaultMQProducer.start(); return defaultMQProducer; } public void removeAndClose(String nameServerAddress, String group) { if (group == null) { group = DEFAULT_GROUP; } String genKey = genKey(nameServerAddress, group); MQProducer producer = getProducerInstance().producerMap.remove(genKey); if (producer != null) { producer.shutdown(); } } public void closeAll() { Set> entries = getProducerInstance().producerMap.entrySet(); for (Map.Entry entry : entries) { getProducerInstance().producerMap.remove(entry.getKey()); entry.getValue().shutdown(); } } } ================================================ FILE: logappender/src/main/java/org/apache/rocketmq/logappender/log4j/RocketmqLog4jAppender.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.logappender.log4j; import org.apache.rocketmq.common.message.Message; import org.apache.rocketmq.logappender.common.ProducerInstance; import org.apache.log4j.AppenderSkeleton; import org.apache.log4j.helpers.LogLog; import org.apache.log4j.spi.ErrorCode; import org.apache.log4j.spi.LoggingEvent; import org.apache.rocketmq.client.producer.MQProducer; /** * Log4j Appender Component */ public class RocketmqLog4jAppender extends AppenderSkeleton { /** * Appended message tag define */ private String tag; /** * Whitch topic to send log messages */ private String topic; private boolean locationInfo; /** * Log producer send instance */ private MQProducer producer; /** * RocketMQ nameserver address */ private String nameServerAddress; /** * Log producer group */ private String producerGroup; public RocketmqLog4jAppender() { } public void activateOptions() { LogLog.debug("Getting initial context."); if (!checkEntryConditions()) { return; } try { producer = ProducerInstance.getProducerInstance().getInstance(nameServerAddress, producerGroup); } catch (Exception e) { LogLog.error("activateOptions nameserver:" + nameServerAddress + " group:" + producerGroup + " " + e.getMessage()); } } /** * Info,error,warn,callback method implementation */ public void append(LoggingEvent event) { if (null == producer) { return; } if (locationInfo) { event.getLocationInformation(); } byte[] data = this.layout.format(event).getBytes(); try { Message msg = new Message(topic, tag, data); msg.getProperties().put(ProducerInstance.APPENDER_TYPE, ProducerInstance.LOG4J_APPENDER); //Send message and do not wait for the ack from the message broker. producer.sendOneway(msg); } catch (Exception e) { String msg = new String(data); errorHandler.error("Could not send message in RocketmqLog4jAppender [" + name + "].Message is :" + msg, e, ErrorCode.GENERIC_FAILURE); } } protected boolean checkEntryConditions() { String fail = null; if (this.topic == null) { fail = "No topic"; } else if (this.tag == null) { fail = "No tag"; } if (fail != null) { errorHandler.error(fail + " for RocketmqLog4jAppender named [" + name + "]."); return false; } else { return true; } } /** * When system exit,this method will be called to close resources */ public synchronized void close() { // The synchronized modifier avoids concurrent append and close operations if (this.closed) return; LogLog.debug("Closing RocketmqLog4jAppender [" + name + "]."); this.closed = true; try { ProducerInstance.getProducerInstance().removeAndClose(this.nameServerAddress, this.producerGroup); } catch (Exception e) { LogLog.error("Closing RocketmqLog4jAppender [" + name + "] nameServerAddress:" + nameServerAddress + " group:" + producerGroup + " " + e.getMessage()); } // Help garbage collection producer = null; } public boolean requiresLayout() { return true; } public String getTopic() { return topic; } public void setTopic(String topic) { this.topic = topic; } public String getTag() { return tag; } public void setTag(String tag) { this.tag = tag; } /** * Returns value of the LocationInfo property which * determines whether location (stack) info is sent to the remote * subscriber. */ public boolean isLocationInfo() { return locationInfo; } /** * If true, the information sent to the remote subscriber will * include caller's location information. By default no location * information is sent to the subscriber. */ public void setLocationInfo(boolean locationInfo) { this.locationInfo = locationInfo; } /** * Returns the message producer,Only valid after * activateOptions() method has been invoked. */ protected MQProducer getProducer() { return producer; } public void setNameServerAddress(String nameServerAddress) { this.nameServerAddress = nameServerAddress; } public void setProducerGroup(String producerGroup) { this.producerGroup = producerGroup; } } ================================================ FILE: logappender/src/main/java/org/apache/rocketmq/logappender/log4j2/RocketmqLog4j2Appender.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.logappender.log4j2; import org.apache.logging.log4j.core.Appender; import org.apache.logging.log4j.core.Filter; import org.apache.logging.log4j.core.ErrorHandler; import org.apache.logging.log4j.core.Layout; import org.apache.logging.log4j.core.LogEvent; import org.apache.logging.log4j.core.config.Node; import org.apache.logging.log4j.core.config.plugins.Plugin; import org.apache.logging.log4j.core.config.plugins.PluginBuilderAttribute; import org.apache.logging.log4j.core.config.plugins.PluginBuilderFactory; import org.apache.logging.log4j.core.config.plugins.PluginElement; import org.apache.rocketmq.common.message.Message; import org.apache.rocketmq.logappender.common.ProducerInstance; import org.apache.logging.log4j.core.appender.AbstractAppender; import org.apache.logging.log4j.core.config.plugins.validation.constraints.Required; import org.apache.logging.log4j.core.layout.SerializedLayout; import org.apache.rocketmq.client.producer.MQProducer; import java.io.Serializable; import java.util.concurrent.TimeUnit; /** * Log4j2 Appender Component */ @Plugin(name = "RocketMQ", category = Node.CATEGORY, elementType = Appender.ELEMENT_TYPE, printObject = true) public class RocketmqLog4j2Appender extends AbstractAppender { /** * RocketMQ nameserver address */ private String nameServerAddress; /** * Log producer group */ private String producerGroup; /** * Log producer send instance */ private MQProducer producer; /** * Appended message tag define */ private String tag; /** * Whitch topic to send log messages */ private String topic; protected RocketmqLog4j2Appender(String name, Filter filter, Layout layout, boolean ignoreExceptions, String nameServerAddress, String producerGroup, String topic, String tag) { super(name, filter, layout, ignoreExceptions); this.producer = producer; this.topic = topic; this.tag = tag; this.nameServerAddress = nameServerAddress; this.producerGroup = producerGroup; try { this.producer = ProducerInstance.getProducerInstance().getInstance(this.nameServerAddress, this.producerGroup); } catch (Exception e) { ErrorHandler handler = this.getHandler(); if (handler != null) { handler.error("Starting RocketmqLog4j2Appender [" + this.getName() + "] nameServerAddress:" + nameServerAddress + " group:" + producerGroup + " " + e.getMessage()); } } } /** * Info,error,warn,callback method implementation */ public void append(LogEvent event) { if (null == producer) { return; } byte[] data = this.getLayout().toByteArray(event); try { Message msg = new Message(topic, tag, data); msg.getProperties().put(ProducerInstance.APPENDER_TYPE, ProducerInstance.LOG4J2_APPENDER); //Send message and do not wait for the ack from the message broker. producer.sendOneway(msg); } catch (Exception e) { ErrorHandler handler = this.getHandler(); if (handler != null) { String msg = new String(data); handler.error("Could not send message in RocketmqLog4j2Appender [" + this.getName() + "].Message is : " + msg, e); } } } /** * When system exit,this method will be called to close resources */ public boolean stop(long timeout, TimeUnit timeUnit) { this.setStopping(); try { ProducerInstance.getProducerInstance().removeAndClose(this.nameServerAddress, this.producerGroup); } catch (Exception e) { ErrorHandler handler = this.getHandler(); if (handler != null) { handler.error("Closeing RocketmqLog4j2Appender [" + this.getName() + "] nameServerAddress:" + nameServerAddress + " group:" + producerGroup + " " + e.getMessage()); } } boolean stopped = super.stop(timeout, timeUnit, false); this.setStopped(); return stopped; } /** * Log4j2 builder creator */ @PluginBuilderFactory public static RocketmqLog4j2Appender.Builder newBuilder() { return new RocketmqLog4j2Appender.Builder(); } /** * Log4j2 xml builder define */ public static class Builder implements org.apache.logging.log4j.core.util.Builder { @PluginBuilderAttribute @Required(message = "A name for the RocketmqLog4j2Appender must be specified") private String name; @PluginElement("Layout") private Layout layout; @PluginElement("Filter") private Filter filter; @PluginBuilderAttribute private boolean ignoreExceptions; @PluginBuilderAttribute private String tag; @PluginBuilderAttribute private String nameServerAddress; @PluginBuilderAttribute private String producerGroup; @PluginBuilderAttribute @Required(message = "A topic name must be specified") private String topic; private Builder() { this.layout = SerializedLayout.createLayout(); this.ignoreExceptions = true; } public RocketmqLog4j2Appender.Builder setName(String name) { this.name = name; return this; } public RocketmqLog4j2Appender.Builder setLayout(Layout layout) { this.layout = layout; return this; } public RocketmqLog4j2Appender.Builder setFilter(Filter filter) { this.filter = filter; return this; } public RocketmqLog4j2Appender.Builder setIgnoreExceptions(boolean ignoreExceptions) { this.ignoreExceptions = ignoreExceptions; return this; } public RocketmqLog4j2Appender.Builder setTag(final String tag) { this.tag = tag; return this; } public RocketmqLog4j2Appender.Builder setTopic(final String topic) { this.topic = topic; return this; } public RocketmqLog4j2Appender.Builder setNameServerAddress(String nameServerAddress) { this.nameServerAddress = nameServerAddress; return this; } public RocketmqLog4j2Appender.Builder setProducerGroup(String producerGroup) { this.producerGroup = producerGroup; return this; } public RocketmqLog4j2Appender build() { return new RocketmqLog4j2Appender(name, filter, layout, ignoreExceptions, nameServerAddress, producerGroup, topic, tag); } } } ================================================ FILE: logappender/src/main/java/org/apache/rocketmq/logappender/logback/RocketmqLogbackAppender.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.logappender.logback; import ch.qos.logback.classic.net.LoggingEventPreSerializationTransformer; import ch.qos.logback.classic.spi.ILoggingEvent; import ch.qos.logback.core.AppenderBase; import ch.qos.logback.core.Layout; import ch.qos.logback.core.spi.PreSerializationTransformer; import ch.qos.logback.core.status.ErrorStatus; import org.apache.rocketmq.common.message.Message; import org.apache.rocketmq.logappender.common.ProducerInstance; import org.apache.rocketmq.client.producer.MQProducer; /** * Logback Appender Component */ public class RocketmqLogbackAppender extends AppenderBase { /** * Message tag define */ private String tag; /** * Whitch topic to send log messages */ private String topic; /** * RocketMQ nameserver address */ private String nameServerAddress; /** * Log producer group */ private String producerGroup; /** * Log producer send instance */ private MQProducer producer; private Layout layout; private PreSerializationTransformer pst = new LoggingEventPreSerializationTransformer(); /** * Info,error,warn,callback method implementation */ @Override protected void append(ILoggingEvent event) { if (!isStarted()) { return; } String logStr = this.layout.doLayout(event); try { Message msg = new Message(topic, tag, logStr.getBytes()); msg.getProperties().put(ProducerInstance.APPENDER_TYPE, ProducerInstance.LOGBACK_APPENDER); //Send message and do not wait for the ack from the message broker. producer.sendOneway(msg); } catch (Exception e) { addError("Could not send message in RocketmqLogbackAppender [" + name + "]. Message is : " + logStr, e); } } /** * Options are activated and become effective only after calling this method. */ public void start() { int errors = 0; if (this.layout == null) { addStatus(new ErrorStatus("No layout set for the RocketmqLogbackAppender named \"" + name + "\".", this)); errors++; } if (errors > 0 || !checkEntryConditions()) { return; } try { producer = ProducerInstance.getProducerInstance().getInstance(nameServerAddress, producerGroup); } catch (Exception e) { addError("Starting RocketmqLogbackAppender [" + this.getName() + "] nameServerAddress:" + nameServerAddress + " group:" + producerGroup + " " + e.getMessage()); } if (producer != null) { super.start(); } } /** * When system exit,this method will be called to close resources */ public synchronized void stop() { // The synchronized modifier avoids concurrent append and close operations if (!this.started) { return; } this.started = false; try { ProducerInstance.getProducerInstance().removeAndClose(this.nameServerAddress, this.producerGroup); } catch (Exception e) { addError("Closeing RocketmqLogbackAppender [" + this.getName() + "] nameServerAddress:" + nameServerAddress + " group:" + producerGroup + " " + e.getMessage()); } // Help garbage collection producer = null; } protected boolean checkEntryConditions() { String fail = null; if (this.topic == null) { fail = "No topic"; } if (fail != null) { addError(fail + " for RocketmqLogbackAppender named [" + name + "]."); return false; } else { return true; } } public Layout getLayout() { return this.layout; } /** * Set the pattern layout to format the log. */ public void setLayout(Layout layout) { this.layout = layout; } public String getTag() { return tag; } public void setTag(String tag) { this.tag = tag; } public String getTopic() { return topic; } public void setTopic(String topic) { this.topic = topic; } public void setNameServerAddress(String nameServerAddress) { this.nameServerAddress = nameServerAddress; } public void setProducerGroup(String producerGroup) { this.producerGroup = producerGroup; } } ================================================ FILE: logappender/src/test/java/org/apache/rocketmq/logappender/AbstractTestCase.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.logappender; import org.apache.rocketmq.client.producer.DefaultMQProducer; import org.apache.rocketmq.common.message.*; import org.apache.rocketmq.logappender.common.ProducerInstance; import org.junit.Before; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; import static org.mockito.Mockito.*; import java.lang.reflect.Field; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.atomic.AtomicInteger; /** * Basic test rocketmq broker and name server init */ public class AbstractTestCase { private static CopyOnWriteArrayList messages = new CopyOnWriteArrayList<>(); @Before public void mockLoggerAppender() throws Exception { DefaultMQProducer defaultMQProducer = spy(new DefaultMQProducer("loggerAppender")); doAnswer(new Answer() { @Override public Void answer(InvocationOnMock invocationOnMock) throws Throwable { Message message = (Message) invocationOnMock.getArgument(0); messages.add(message); return null; } }).when(defaultMQProducer).sendOneway(any(Message.class)); ProducerInstance spy = mock(ProducerInstance.class); Field instance = ProducerInstance.class.getDeclaredField("instance"); instance.setAccessible(true); instance.set(ProducerInstance.class, spy); doReturn(defaultMQProducer).when(spy).getInstance(anyString(), anyString()); } public void clear() { } protected int consumeMessages(int count, final String key, int timeout) { final AtomicInteger cc = new AtomicInteger(0); for (Message message : messages) { String body = new String(message.getBody()); if (body.contains(key)) { cc.incrementAndGet(); } } return cc.get(); } } ================================================ FILE: logappender/src/test/java/org/apache/rocketmq/logappender/Log4jPropertiesTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.logappender; import org.apache.log4j.PropertyConfigurator; public class Log4jPropertiesTest extends Log4jTest { @Override public void init() { PropertyConfigurator.configure("src/test/resources/log4j-example.properties"); } @Override public String getType() { return "properties"; } } ================================================ FILE: logappender/src/test/java/org/apache/rocketmq/logappender/Log4jTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.logappender; import org.apache.log4j.Logger; import org.junit.Assert; import org.junit.Before; import org.junit.Test; public abstract class Log4jTest extends AbstractTestCase { @Before public abstract void init(); public abstract String getType(); @Test public void testLog4j() { clear(); Logger logger = Logger.getLogger("testLogger"); for (int i = 0; i < 10; i++) { logger.info("log4j " + this.getType() + " simple test message " + i); } int received = consumeMessages(10, "log4j", 10); Assert.assertTrue(received > 5); } } ================================================ FILE: logappender/src/test/java/org/apache/rocketmq/logappender/Log4jXmlTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.logappender; import org.apache.log4j.xml.DOMConfigurator; public class Log4jXmlTest extends Log4jTest { @Override public void init() { DOMConfigurator.configure("src/test/resources/log4j-example.xml"); } @Override public String getType() { return "xml"; } } ================================================ FILE: logappender/src/test/java/org/apache/rocketmq/logappender/LogbackTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.logappender; import ch.qos.logback.classic.LoggerContext; import ch.qos.logback.classic.joran.JoranConfigurator; import ch.qos.logback.core.joran.spi.JoranException; import ch.qos.logback.core.util.StatusPrinter; import java.io.File; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class LogbackTest extends AbstractTestCase { @Before public void init() throws JoranException { LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory(); JoranConfigurator configurator = new JoranConfigurator(); configurator.setContext(lc); lc.reset(); configurator.doConfigure(new File("src/test/resources/logback-example.xml")); StatusPrinter.printInCaseOfErrorsOrWarnings(lc); } @Test public void testLogback() { clear(); Logger logger = LoggerFactory.getLogger("testLogger"); for (int i = 0; i < 10; i++) { logger.info("logback test message " + i); } int received = consumeMessages(10, "logback", 10); Assert.assertTrue(received >= 5); } } ================================================ FILE: logappender/src/test/java/org/apache/rocketmq/logappender/log4j2Test.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.logappender; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.core.config.Configurator; import org.apache.rocketmq.client.exception.MQClientException; import org.junit.Assert; import org.junit.Before; import org.junit.Test; public class log4j2Test extends AbstractTestCase { @Before public void init() { Configurator.initialize("log4j2", "src/test/resources/log4j2-example.xml"); } @Test public void testLog4j2() throws InterruptedException, MQClientException { clear(); Logger logger = LogManager.getLogger("test"); for (int i = 0; i < 10; i++) { logger.info("log4j2 log message " + i); } int received = consumeMessages(10, "log4j2", 10); Assert.assertTrue(received > 5); } } ================================================ FILE: logappender/src/test/resources/log4j-example.properties ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. log4j.rootLogger=INFO,stdout log4j.logger.testLogger=INFO,mq log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target=System.out log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%d %-4r [%t] (%F:%L) %-5p - %m%n log4j.appender.store=org.apache.log4j.DailyRollingFileAppender log4j.appender.store.File=${user.home}/logs/rocketmqlogs/appender.log log4j.appender.store.Append=true log4j.appender.store.DatePattern='_'yyyy-MM-dd'.log' log4j.appender.store.layout=org.apache.log4j.PatternLayout log4j.appender.store.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-4r [%t] (%F:%L) %-5p - %m%n log4j.appender.mq=org.apache.rocketmq.logappender.log4j.RocketmqLog4jAppender log4j.appender.mq.Tag=log log4j.appender.mq.Topic=TopicTest log4j.appender.mq.ProducerGroup=loggerAppender log4j.appender.mq.NameServerAddress=127.0.0.1:9876 log4j.appender.mq.layout=org.apache.log4j.PatternLayout log4j.appender.mq.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-4r [%t] (%F:%L) %-5p - %m%n ================================================ FILE: logappender/src/test/resources/log4j-example.xml ================================================ ================================================ FILE: logappender/src/test/resources/log4j2-example.xml ================================================ ================================================ FILE: logappender/src/test/resources/logback-example.xml ================================================ ${user.home}/logs/simple/system.log true ${user.home}/logs/simple/system.%i.log 1 30 100MB %date %p %t - %m%n UTF-8 System.out %date %p %t - %m%n UTF-8 ${user.home}/logs/simple/daily.log ${user.home}/logs/simple/daily.log.%d{yyyy-MM-dd_HH} 30 %date %p %t - %m%n log1 TopicTest loggerAppender 127.0.0.1:9876 %date %p %t - %m%n ================================================ FILE: rocketmq-ansible/Rocketmq Ansible Playbook cn.md ================================================ Apache RocketMQ Playbook提供Apache RocketMQ集群部署和Apache RocketMQ Exporter部署功能。 Apache RocketMQ Playbook集成了部署环境初始化、可运行包下载、os参数调优、broker最佳配置参数、Apache RocketMQ集群部署、Apache RocketMQ Exporter部署、Apache RocketMQ Exporter接入prometheus、添加开机自启动机制等任务编排到一起。 Apache RocketMQ Playbook可以嵌入在CI/CD流程中或者编排到terraform流程中，这在自动化运维或者VDC一键部署（SDE）有非常重要的意义。 ## 使用说明 ## 先决条件 安装Ansible。Ansible是一个自动化运维工具，可以进行配置管理和应用部署。实现了批量系统配置、批量程序部署、批量运行命令等功能。 安装文档参考官网 [https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html](https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html) ## Playbook结构 Apache RocketMQ Playbook入口文件为rocketmq.yml。rocketmq.yml包含namesrv.yml、broker.yml、exporter.yml 3个子playbook。 rocketmq.yml可以单独执行部署一个完整的rocketmq集群或者3个子playbook单独执行。 hosts文件配置了namesrv、broker、exporter部署的机器列表及变量，当使用terraform编排时hosts可以当做变量传递。 rocketmq-ansible │ │  broker.yml#部署broker │  exporter.yml#部署exporter │  hosts#部署机器列表及变量 │  namesrv.yml#部署namesrv │  rocketmq.yml#playbook入口文件 │   ├─roles │  ├─broker │  │  ├─tasks │  │  │      main.yml #部署broker流程 │  │  │       │  │  ├─templates │  │  │      broker.conf.j2 #broker最佳配置模版 │  │  │      logback_broker.xml.j2 #broker logback配置模版 │  │  │      mqbroker.service #broker开机自启动脚本模版 │  │  │       │  │  └─vars │  │          main.yml #broker.yml使用的变量 │  │           │  ├─exporter │  │  ├─files │  │  │      mqexportershutdown.sh #exporter停止脚本 │  │  │       │  │  ├─tasks │  │  │      main.yml #exporter部署流程 │  │  │       │  │  ├─templates │  │  │      mqexporter.service #exporter开机自动脚本模版 │  │  │      mqexporter.sh.j2 #exporter启动脚本模版 │  │  │       │  │  └─vars │  │          main.yml #exporter.yml使用的变量 │  │           │  └─namesrv │      ├─tasks │      │      main.yml #namesrv部署流程 │      │       │      ├─templates │      │      logback_namesrv.xml.j2 #namesrv logback配置模版 │      │      mqnamesrv.service #namesrv开机自启动脚本模版 │      │       │      └─vars │              main.yml #namesrv.yml使用的变量 │               └─vars         main.yml #rocketmq.yml使用的变量 ## Playbook执行 ansible-playbook /path/rocketmq.yml -i /path/hosts ## rocketmq.yml rocketmq.yml描述了使用linux root用户部署。在执行部署之前做一些环境初始化任务，创建应用文件目录和数据文件目录。 ## namesrv.yml namesrv.yml描述了部署namesrv的过程。包含了创建部署目录、下载可运行包、修改日志文件目录、添加开机自启动机制、启动进程等任务。 ## broker.yml broker.yml描述了部署broker的过程。包含了创建部署目录、下载可运行包、修改日志文件目录、优化os参数、优化broker配置、添加开机自启动机制、启动进程等任务。 ## exporter.yml exporter.yml描述了部署rocketmq exporter的过程。包含了创建部署目录、下载Apache RocketMQ Exporter可运行包、生成启动和停止脚本、添加开机自启动机制、启动进程等任务。 ================================================ FILE: rocketmq-ansible/Rocketmq Ansible Playbook en.md ================================================ Apache RocketMQ Playbook provides the Apache RocketMQ cluster deployment and Apache RocketMQ Exporter deployment function. Apache RocketMQ Playbook integrates deployment environment initialization, runnable pack download, os parameter tuning, broker optimal configuration parameters, Apache RocketMQ cluster deployment, Apache RocketMQ Exporter deployment, Apache RocketMQ Exporter access to prometheus, and startup. The Apache RocketMQ Playbook can be embedded in CI/CD processes or choreographed into Terraform processes, making it important for automated operations or VDC one-click deployment (SDE). ## instructions ## prerequisite Install Ansible. Ansible is an agentless automation tool for configuration management and application deployment. Realized batch system configuration, batch program deployment, batch running commands and other functions. Installation documents refer to the official website: [https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html](https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html) ## Structure of playbook The Apache RocketMQ Playbook entry file is rocketmq.yml. Rocketmq.yml contains namesrv.yml, broker.yml, and exporter. Rocketmq.yml can be executed separately by deploying a full Apache RocketMQ cluster or three child Playbooks. The hosts file is configured with a list of machines and variables for Namesrv, Broker, and exporter deployment. The hosts file can be used as a variable. rocketmq-ansible │ │  broker.yml #Deploy the broker │  exporter.yml #Deploy the exporter │  hosts #Deploy machine list and variables │  namesrv.yml #Deploy the namesrv │  rocketmq.yml #Playbook entry file │   ├─roles │  ├─broker │  │  ├─tasks │  │  │      main.yml #Deploy the Broker process │  │  │       │  │  ├─templates │  │  │      broker.conf.j2 #Broker best configuration template │  │  │      logback_broker.xml.j2 #Broker Logback configuration template │  │  │      mqbroker.service #Self boot automatic script template │  │  │       │  │  └─vars │  │          main.yml #The variable used by broker.yml │  │           │  ├─exporter │  │  ├─files │  │  │      mqexportershutdown.sh #Exporter stop script │  │  │       │  │  ├─tasks │  │  │      main.yml #Export Deployment Process │  │  │       │  │  ├─templates │  │  │      mqexporter.service #Self boot automatic script template │  │  │      mqexporter.sh.j2 #Exporter startup script template │  │  │       │  │  └─vars │  │          main.yml #A variable used by exporter.yml │  │           │  └─namesrv │      ├─tasks │      │      main.yml #Namesrv deployment process │      │       │      ├─templates │      │      logback_namesrv.xml.j2 #Namesrv logback configuration template │      │      mqnamesrv.service #Self boot automatic script template │      │       │      └─vars │              main.yml #The variable used by namesrv.yml │               └─vars         main.yml #The variable used by rocketmq.yml ## Perform playbook ansible-playbook /path/rocketmq.yml -i /path/hosts ## rocketmq.yml rocketmq.yml describes how to deploy as Linux root user, perform some deployment environment initialization tasks, and create application file directories and data file directories before executing three sub-Playbooks. ## namesrv.yml namesrv.yml describes the process of deploying namesrv. This includes creating a deployment directory, downloading Apache RocketMQ pack, modifying the log file directory, adding a startup mechanism, and starting processes. ## broker.yml broker.yml describes the process of deploying the broker. This includes creating a deployment directory, downloading Apache RocketMQ pack, modifying log file directories, optimizing os parameters, optimizing broker configuration, adding a startup mechanism, and starting processes. ## exporter.yml exporter.yml describes the process of deploying Apache RocketMQ Exporter. It contains tasks such as creating a deployment directory, downloading Apache RocketMQ Exporter pack, generating startup and stop scripts, adding a self-boot mechanism, and starting processes. ================================================ FILE: rocketmq-ansible/broker.yml ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # deploy Apache Rocketmq broker - hosts: rocketmq_broker roles: - broker ================================================ FILE: rocketmq-ansible/exporter.yml ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # deploy Apache Rocketmq exporter - hosts: rocketmq_exporter roles: - exporter ================================================ FILE: rocketmq-ansible/hosts ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. #hosts example, please change the value based on the actual situation #Apache Rocketmq namesrv [rocketmq_namesrv] 127.0.0.1 127.0.0.2 #Apache Rocketmq broker [rocketmq_broker] 127.0.0.3 brokerName=broker-a brokerId=0 brokerRole=SYNC_MASTER 127.0.0.4 brokerName=broker-a brokerId=1 brokerRole=SLAVE [rocketmq_broker:vars] brokerClusterName=DefaultCluster namesrvAddr=127.0.0.1:9876;127.0.0.2:9876 storePathRootDir=/root/store #Apache Rocketmq exporter [rocketmq_exporter] 127.0.0.5 [rocketmq_exporter:vars] namesrvAddr=127.0.0.1:9876;127.0.0.2:9876 webTelemetryPath=/metrics rocketmqVersion=V4_7_1 ================================================ FILE: rocketmq-ansible/namesrv.yml ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # deploy Apache Rocketmq namesrv - hosts: rocketmq_namesrv roles: - namesrv ================================================ FILE: rocketmq-ansible/rocketmq.yml ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # deploy Apache Rocketmq cluster - name: Apache Rocketmq hosts: all become: yes become_user: root become_method: sudo gather_facts: False vars_files: - vars/main.yml pre_tasks: - name: create rocketmq deploy path file: path: "{{ rocketmq_deploy_path }}" state: directory recurse: yes - name: create rocketmq log path file: path: "{{ rocketmq_log_path }}" state: directory recurse: yes - include: namesrv.yml - include: broker.yml - include: exporter.yml ================================================ FILE: rocketmq-ansible/roles/broker/tasks/main.yml ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. - name: check broker deploy directory stat: path: "{{ rocketmq_deploy_path }}/rocketmq" register: deploy_directory - debug: msg: "{{ deploy_directory }}" - name: download Apache Rocketmq unarchive: src: "{{ rocketmq_download_url }}" dest: "{{ rocketmq_deploy_path }}" remote_src: yes mode: 0750 when: deploy_directory.stat.exists == False - name: rename broker deploy directory shell: cd {{ rocketmq_deploy_path }}; if [ ! -d "rocketmq" ]; then mv rocketmq-* rocketmq; fi - name: modify broker log path template: src: logback_broker.xml.j2 dest: "{{ rocketmq_deploy_path }}/rocketmq/conf/logback_broker.xml" - name: modify broker config template: src: broker.conf.j2 dest: "{{ rocketmq_deploy_path }}/rocketmq/conf/broker.conf" - name: add broker boot mechanism template: src: mqbroker.service dest: /usr/lib/systemd/system mode: 0750 - name: check broker process shell: source /etc/profile && jps | grep BrokerStartup | wc -l register: check_status - debug: msg: "{{ check_status }}" - name: optimize os shell: source /etc/profile && sh {{ rocketmq_deploy_path }}/rocketmq/bin/os.sh when: deploy_directory.stat.exists == False - name: start broker shell: | source /etc/profile systemctl disable mqbroker systemctl enable mqbroker systemctl stop mqbroker systemctl start mqbroker when: check_status.stdout|int == 0 ================================================ FILE: rocketmq-ansible/roles/broker/templates/broker.conf.j2 ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. brokerClusterName={{ brokerClusterName }} brokerName={{ brokerName }} brokerId={{ brokerId }} namesrvAddr={{ namesrvAddr }} autoCreateTopicEnable=false sendMessageThreadPoolNums=4 waitTimeMillsInSendQueue=1000 sendThreadPoolQueueCapacity=20000 brokerRole={{ brokerRole }} flushDiskType=ASYNC_FLUSH storePathRootDir={{ storePathRootDir }} storePathCommitLog={{ storePathRootDir }}/commitlog #maxMessageSize=1048576 messageDelayLevel=1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h osPageCacheBusyTimeOutMills=1500 #transientStorePoolEnable=true diskMaxUsedSpaceRatio=88 fileReservedTime=168 ================================================ FILE: rocketmq-ansible/roles/broker/templates/logback_broker.xml.j2 ================================================ {{ rocketmq_log_path }}/logs/rocketmqlogs/broker_default.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/broker_default.%i.log.gz 1 10 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p %t - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/broker.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/broker.%i.log.gz 1 20 128MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p %t - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/protection.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/protection.%i.log.gz 1 10 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/watermark.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/watermark.%i.log.gz 1 10 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/store.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/store.%i.log.gz 1 10 128MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p %t - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/remoting.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/remoting.%i.log.gz 1 10 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p %t - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/storeerror.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/storeerror.%i.log.gz 1 10 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p %t - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/transaction.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/transaction.%i.log.gz 1 10 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p %t - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/lock.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/lock.%i.log.gz 1 5 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p %t - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/filter.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/filter.%i.log.gz 1 10 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p %t - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/stats.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/stats.%i.log.gz 1 5 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/commercial.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/commercial.%i.log.gz 1 10 500MB true %d{yyy-MM-dd HH\:mm\:ss,GMT+8} %p %t - %m%n UTF-8 ================================================ FILE: rocketmq-ansible/roles/broker/templates/mqbroker.service ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. [Unit] Description=rocketmq namesrv service After=network.target [Service] Type=simple ExecStart=/bin/bash -c 'source /etc/profile && {{ rocketmq_deploy_path }}/rocketmq/bin/mqbroker -c {{ rocketmq_deploy_path }}/rocketmq/conf/broker.conf' ExecStop=/bin/bash -c 'source /etc/profile && {{ rocketmq_deploy_path }}/rocketmq/bin/mqshutdown broker' RemainAfterExit=yes LimitNOFILE=655350 LimitMEMLOCK=infinity Restart=always RestartSec=5s [Install] WantedBy=multi-user.target ================================================ FILE: rocketmq-ansible/roles/broker/vars/main.yml ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # broker variable rocketmq_download_url: https://dlcdn.apache.org/rocketmq/4.9.3/rocketmq-all-4.9.3-bin-release.zip rocketmq_deploy_path: /app rocketmq_log_path: ${user.home} ================================================ FILE: rocketmq-ansible/roles/exporter/files/mqexportershutdown.sh ================================================ #!/bin/sh # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. source /etc/profile pid=$(jps -lvVm | grep rocketmq-exporter | awk '{print $1}') if [ ! -z $pid ]; then kill -9 $pid fi ================================================ FILE: rocketmq-ansible/roles/exporter/tasks/main.yml ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. - name: create exporter deploy directory file: path: "{{ rocketmq_exporter_deploy_directory }}" state: directory recurse: yes - name: download Apache Rocketmq exporter get_url: url: "{{ rocketmq_exporter_download_url }}" dest: "{{ rocketmq_exporter_deploy_directory }}" mode: 0750 - name: copy exporter shutdown script copy: src: mqexportershutdown.sh dest: "{{ rocketmq_exporter_deploy_directory }}" mode: 0750 - name: copy exporter start script template: src: mqexporter.sh.j2 dest: "{{rocketmq_exporter_deploy_directory}}/mqexporter.sh" mode: 0750 - name: add exporter boot mechanism template: src: mqexporter.service dest: /usr/lib/systemd/system mode: 0750 - name: check exporter status shell: source /etc/profile && jps -lvVm | grep rocketmq-exporter | wc -l register: status_result - debug: msg: "{{ status_result }}" - name: start exporter shell: | source /etc/profile systemctl disable mqexporter systemctl enable mqexporter systemctl stop mqexporter systemctl start mqexporter when: status_result.stdout|int == 0 ================================================ FILE: rocketmq-ansible/roles/exporter/templates/mqexporter.service ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. [Unit] Description=rocketmq exporter service After=network.target [Service] Type=simple ExecStart=/bin/bash -c 'source /etc/profile && {{ rocketmq_exporter_deploy_directory }}/mqexporter.sh' ExecStop=/bin/bash -c 'source /etc/profile && {{ rocketmq_exporter_deploy_directory }}/mqexportershutdown.sh' RemainAfterExit=yes Restart=always RestartSec=5s [Install] WantedBy=multi-user.target ================================================ FILE: rocketmq-ansible/roles/exporter/templates/mqexporter.sh.j2 ================================================ #!/bin/sh # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. source /etc/profile nohup java -Drocketmq.namesrv.addr="{{ namesrvAddr }}" \ -Drocketmq.config.webTelemetryPath={{ webTelemetryPath }} \ -Drocketmq.config.rocketmqVersion={{ rocketmqVersion }} \ -jar {{ rocketmq_exporter_deploy_directory }}/rocketmq-exporter-0.0.2-SNAPSHOT.jar & ================================================ FILE: rocketmq-ansible/roles/exporter/vars/main.yml ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. #exporter need build by yourself rocketmq_exporter_download_url: http://rocketmq.exporter/rocketmq-exporter-0.0.2-SNAPSHOT.jar rocketmq_exporter_deploy_directory: /app/exporter ================================================ FILE: rocketmq-ansible/roles/namesrv/tasks/main.yml ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. - name: check namesrv deploy directory stat: path: "{{ rocketmq_deploy_path }}/rocketmq" register: deploy_directory - debug: msg: "{{ deploy_directory }}" - name: download Apache Rocketmq unarchive: src: "{{ rocketmq_download_url }}" dest: "{{ rocketmq_deploy_path }}" remote_src: yes mode: 0750 when: deploy_directory.stat.exists == False - name: rename namesrv deploy directory shell: cd {{ rocketmq_deploy_path }}; if [ ! -d "rocketmq" ]; then mv rocketmq-* rocketmq; fi - name: modify namesrv log path template: src: logback_namesrv.xml.j2 dest: "{{ rocketmq_deploy_path }}/rocketmq/conf/logback_namesrv.xml" - name: add namesrv boot mechanism template: src: mqnamesrv.service dest: /usr/lib/systemd/system mode: 0750 - name: check namesrv status shell: source /etc/profile && jps | grep NamesrvStartup | wc -l register: check_status - debug: msg: "{{ check_status }}" - name: start namesrv shell: | source /etc/profile systemctl disable mqnamesrv systemctl enable mqnamesrv systemctl stop mqnamesrv systemctl start mqnamesrv when: check_status.stdout|int == 0 ================================================ FILE: rocketmq-ansible/roles/namesrv/templates/logback_namesrv.xml.j2 ================================================ {{ rocketmq_log_path }}/logs/rocketmqlogs/namesrv_default.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/namesrv_default.%i.log.gz 1 5 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p %t - %m%n UTF-8 {{ rocketmq_log_path }}/logs/rocketmqlogs/namesrv.log true {{ rocketmq_log_path }}/logs/rocketmqlogs/otherdays/namesrv.%i.log.gz 1 5 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p %t - %m%n UTF-8 0 true %d{yyy-MM-dd HH\:mm\:ss,SSS} %p %t - %m%n UTF-8 ================================================ FILE: rocketmq-ansible/roles/namesrv/templates/mqnamesrv.service ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. [Unit] Description=rocketmq namesrv service After=network.target [Service] Type=simple ExecStart=/bin/bash -c 'source /etc/profile && {{ rocketmq_deploy_path }}/rocketmq/bin/mqnamesrv' ExecStop=/bin/bash -c 'source /etc/profile && {{ rocketmq_deploy_path }}/rocketmq/bin/mqshutdown namesrv' RemainAfterExit=yes Restart=always RestartSec=5s [Install] WantedBy=multi-user.target ================================================ FILE: rocketmq-ansible/roles/namesrv/vars/main.yml ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # namesrv variable rocketmq_download_url: https://dlcdn.apache.org/rocketmq/4.9.3/rocketmq-all-4.9.3-bin-release.zip rocketmq_deploy_path: /app rocketmq_log_path: ${user.home} ================================================ FILE: rocketmq-ansible/vars/main.yml ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # The global variable rocketmq_deploy_path: /app rocketmq_log_path: /data ================================================ FILE: rocketmq-beats-integration/README.md ================================================ # rocketmq-beats-integration This project enables Apache RocketMQ integrate directly with [Elastic Beats](https://www.elastic.co/guide/en/beats/libbeat/current/index.html). ## Compatibility This project is developed and tested using Apache RocketMQ Go Client v2.1.0 and Beats 7.17.0 ## Sending events to Apache RocketMQ in Beats Platform ### 1. Build your Beats The Beats platform provides several Beats, like [Filebeat](https://www.elastic.co/products/beats/filebeat) , [Heartbeat](https://www.elastic.co/products/beats/heartbeat) , [Metricbeat](https://www.elastic.co/products/beats/metricbeat), etc. So you can choose to build one or more Beats according to different sources you want to capture. #### 1.1 Prerequisite At present Beats Platform does not provide ways to integrate a custom output at runtime, so you must build Beats with this codebase to generate a new Beat to support output to Apache RocketMQ. You can obtain a copy of the Beat codebase with the following git command: ```shell git clone --branch --single-branch https://github.com/elastic/beats.git ``` The `branch_name` should be the version of Beats you want to use. In the following `` is denoted by `$BEATS_HOME`. #### 1.2 Build specified Beats **1.2.1** clone this codebase to your local repository, then copy the folder `rocketmq` under `libbeat/output` to `$BEATS_HOME/libbeat/output/`. **1.2.2** add `_ "github.com/elastic/beats/v7/libbeat/outputs/rocketmq"` in the `import` part of `$BEATS_HOME/libbeat/publisher/includes/includes.go`: ```golang import ( // import queue types _ "github.com/elastic/beats/v7/libbeat/outputs/codec/format" _ "github.com/elastic/beats/v7/libbeat/outputs/codec/json" _ "github.com/elastic/beats/v7/libbeat/outputs/console" _ "github.com/elastic/beats/v7/libbeat/outputs/elasticsearch" _ "github.com/elastic/beats/v7/libbeat/outputs/fileout" _ "github.com/elastic/beats/v7/libbeat/outputs/kafka" _ "github.com/elastic/beats/v7/libbeat/outputs/logstash" _ "github.com/elastic/beats/v7/libbeat/outputs/redis" _ "github.com/elastic/beats/v7/libbeat/outputs/rocketmq" _ "github.com/elastic/beats/v7/libbeat/publisher/queue/diskqueue" _ "github.com/elastic/beats/v7/libbeat/publisher/queue/memqueue" _ "github.com/elastic/beats/v7/libbeat/publisher/queue/spool" ) ``` **1.2.3** run `go mod tidy` to import dependencies of RocketMQ go client, or add the following instruction to `$BEATS_HOME/go.mode`: ```golang require github.com/apache/rocketmq-client-go/v2 v2.1.0 ``` **1.2.4** build your Beats For example, if you want to build filebeat, run the following command: ```shell cd $BEATS_HOME/filebeat/ && make ``` After that, a new executable `filebeat` is generated, and you can use it to send events to Apache RocketMQ. If you want to build other Beats, just enter the specified folder and run `make`. For example: ```shell cd $BEATS_HOME/auditbeat/ && make cd $BEATS_HOME/heartbeat/ && make cd $BEATS_HOME/metricbeat/ && make cd $BEATS_HOME/packetbeat/ && make cd $BEATS_HOME/winlogbeat/ && make ``` ### 2. Run your Beats After you have built your Beats, you can run them to send events to Apache RocketMQ. Here is a simple configuration that can be used to test that if the content of `/var/log/messages` would be sent to RocketMQ successfully. ```yaml filebeat.inputs: - type: filestream enabled: true paths: - /var/log/messages output.rocketmq: nameservers: [ "127.0.0.1:9876" ] topic: TopicTest ``` As you can see above, the only required configuration options are `nameservers` and `topic`, which denotes the name server address array of Apache RocketMQ and the topic where you want to publish the event, respectively. For more details, please reference the next section. Copy the above Filebeat configuration to a file such as `rocketmq_output.yml`. Filebeat should then be started with: ```shell ./filebeat -c rocketmq_output.yml -e ``` ## Configuration Options | Setting | Input type | Required | Default | Description | |:---------------:|:--------------------------------------:|:--------:|:---------------------------------------------------:|-------------------------------------------------------------------------------------------------------------------------------------------------------------------| | nameservers | []string | Yes | | The address list of name servers | | topic | string | Yes | | The topic to produce messages to | | group | string | No | | The producer group | | send_timeout | time.Duration | No | 3s | Send timeout milliseconds | | max_retries | number | No | 2 | Retry times after failing to send the event | | codec | codec | No | plain | The codec used for output data. You can reference [output codec](https://www.elastic.co/guide/en/beats/filebeat/current/configuration-output-codec.html) for more details. | ## Contributing All contributions are welcome: ideas, patches, documentation, bug reports, complaints, and even something you drew up on a napkin. Programming is not a required skill. Whatever you've seen about open source and maintainers or community members saying "send patches or die" - you will not see that here. It is more important to the community that you are able to contribute. ## License [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html) Copyright (C) Apache Software Foundation ================================================ FILE: rocketmq-beats-integration/libbeat/outputs/rocketmq/LICENSE ================================================ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] 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. ================================================ FILE: rocketmq-beats-integration/libbeat/outputs/rocketmq/NOTICE ================================================ Apache RocketMQ (incubating) Copyright 2016-2022 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). ================================================ FILE: rocketmq-beats-integration/libbeat/outputs/rocketmq/client.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package rocketmq import ( "context" "strings" "time" "github.com/apache/rocketmq-client-go/v2" "github.com/apache/rocketmq-client-go/v2/primitive" "github.com/apache/rocketmq-client-go/v2/producer" "github.com/elastic/beats/v7/libbeat/logp" "github.com/elastic/beats/v7/libbeat/outputs" "github.com/elastic/beats/v7/libbeat/outputs/codec" "github.com/elastic/beats/v7/libbeat/publisher" ) type client struct { log *logp.Logger observer outputs.Observer index string codec codec.Codec namesrvAddr []string topic string group string timeout time.Duration maxRetries int producer rocketmq.Producer } func (c *client) Connect() error { c.log.Warnf("connecting: %v", c.namesrvAddr) p, err := rocketmq.NewProducer( producer.WithNsResolver(primitive.NewPassthroughResolver(c.namesrvAddr)), producer.WithRetry(c.maxRetries), producer.WithSendMsgTimeout(c.timeout), producer.WithGroupName(c.group), ) if err != nil { c.log.Errorf("RocketMQ creates producer fails with: %v", err) return err } errStart := p.Start() if errStart != nil { c.log.Errorf("RocketMQ starts producer fails with: %v", errStart) return errStart } c.producer = p return nil } func (c *client) Close() error { c.log.Warn("Enter Close(), shutdown...") if c.producer != nil { c.producer.Shutdown() c.producer = nil } return nil } func (c *client) Publish(_ context.Context, batch publisher.Batch) error { defer batch.ACK() st := c.observer events := batch.Events() st.NewBatch(len(events)) dropped := 0 for i := range events { d := &events[i] ok := c.publishEvent(d) if !ok { dropped++ } } return nil } func (c *client) publishEvent(event *publisher.Event) bool { serializedEvent, err := c.codec.Encode(c.index, &event.Content) if err != nil { c.observer.Dropped(1) if !event.Guaranteed() { return false } c.log.Errorf("Unable to encode event: %v", err) return false } c.observer.WriteBytes(len(serializedEvent) + 1) // str := string(serializedEvent) // c.log.Warnf("Processing event: %v", str) buf := make([]byte, len(serializedEvent)) copy(buf, serializedEvent) msg := &primitive.Message{ Topic: c.topic, Body: buf, } // res, err := c.producer.SendSync(context.Background(), msg) // if err != nil { // c.log.Errorf("send to rocketmq is error %v", err) // return false // } else { // c.log.Warnf("send msg result=%v", res.String()) // } err = c.producer.SendAsync(context.Background(), func(ctx context.Context, result *primitive.SendResult, e error) { if e != nil { c.observer.Dropped(1) c.log.Errorf("send to rocketmq is error %v", e) } else { c.observer.Acked(1) c.log.Debugf("send msg result=%v", result.String()) } }, msg) if err != nil { c.observer.Dropped(1) c.log.Errorf("send to rocketmq is error %v", err) return false } return true } func (c *client) String() string { return "rocketmq[" + strings.Join(c.namesrvAddr, ",") + "]" } ================================================ FILE: rocketmq-beats-integration/libbeat/outputs/rocketmq/config.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package rocketmq import ( "time" "github.com/elastic/beats/v7/libbeat/common" "github.com/elastic/beats/v7/libbeat/outputs/codec" ) type rocketmqConfig struct { Nameservers []string `config:"nameservers" validate:"required"` Topic string `config:"topic" validate:"required"` //Tag string `config:"tag"` Group string `config:"group"` SendTimeout time.Duration `config:"send_timeout" ` MaxRetries int `config:"max_retries"` Codec codec.Config `config:"codec"` // Max number of events in a batch to send to a single client BatchSize int `config:"batch_size" validate:"min=1"` } func defaultConfig() rocketmqConfig { return rocketmqConfig{ Nameservers: nil, Topic: "topic-beats", SendTimeout: 3 * time.Second, MaxRetries: 2, BatchSize: 1, } } func readConfig(cfg *common.Config) (*rocketmqConfig, error) { c := defaultConfig() if err := cfg.Unpack(&c); err != nil { return nil, err } return &c, nil } ================================================ FILE: rocketmq-beats-integration/libbeat/outputs/rocketmq/rocketmq.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package rocketmq import ( "github.com/elastic/beats/v7/libbeat/beat" "github.com/elastic/beats/v7/libbeat/common" "github.com/elastic/beats/v7/libbeat/logp" "github.com/elastic/beats/v7/libbeat/outputs" "github.com/elastic/beats/v7/libbeat/outputs/codec" ) const ( logSelector = "rocketmq" ) func init() { outputs.RegisterType("rocketmq", makeRocketmq) } func makeRocketmq( _ outputs.IndexManager, beat beat.Info, observer outputs.Observer, cfg *common.Config, ) (outputs.Group, error) { log := logp.NewLogger(logSelector) config, err := readConfig(cfg) if err != nil { return outputs.Fail(err) } index := beat.Beat codec, err := codec.CreateEncoder(beat, config.Codec) if err != nil { return outputs.Fail(err) } client := &client{log: log, observer: observer, index: index, codec: codec, namesrvAddr: config.Nameservers, topic: config.Topic, group: config.Group, timeout: config.SendTimeout, maxRetries: config.MaxRetries} //retry in producer, so set it 0 in the following function return outputs.Success(config.BatchSize, 0, client) } ================================================ FILE: rocketmq-cloudevents-binding/pom.xml ================================================ 4.0.0 org.apache.rocketmq rocketmq-cloudevents-binding 1.0.0 rocketmq-cloudevents-binding https://github.com/apache/incubator-rocketmq-externals/tree/master/rocketmq-cloudevents-binding The Apache Software License, Version 2.0 http://www.apache.org/licenses/LICENSE-2.0.txt jira https://issues.apache.org/jira/browse/RocketMQ UTF-8 UTF-8 1.8 1.8 org.codehaus.mojo versions-maven-plugin 2.3 org.codehaus.mojo clirr-maven-plugin 2.7 maven-compiler-plugin 3.6.1 ${maven.compiler.source} ${maven.compiler.target} ${maven.compiler.source} true true maven-surefire-plugin 2.19.1 -Xms512m -Xmx1024m always **/*Test.java maven-site-plugin 3.6 en_US UTF-8 UTF-8 maven-source-plugin 3.0.1 attach-sources jar maven-javadoc-plugin 2.10.4 UTF-8 en_US io.openmessaging.internal aggregate aggregate site maven-resources-plugin 3.0.2 ${project.build.sourceEncoding} org.codehaus.mojo findbugs-maven-plugin 3.0.4 org.apache.rocketmq rocketmq-client 4.9.0 io.cloudevents cloudevents-core 2.2.0 com.google.code.findbugs jsr305 3.0.2 provided true org.junit.jupiter junit-jupiter 5.7.0 io.cloudevents cloudevents-core tests test-jar 2.2.0 test org.assertj assertj-core 3.16.1 test ================================================ FILE: rocketmq-cloudevents-binding/rocketmq-transport-binding.md ================================================ # RocketMQ Transport Binding for CloudEvents ## Abstract The [RocketMQ][RocketMQ] Transport Binding for CloudEvents defines how events are mapped to RocketMQ messages. ## Status of this document This document is a working draft. ## Table of Contents 1. [Introduction](#1-introduction) - 1.1. [Conformance](#11-conformance) - 1.2. [Relation to RocketMQ](#12-relation-to-rocketmq) - 1.3. [Content Modes](#13-content-modes) - 1.4. [Event Formats](#14-event-formats)) - 1.5. [Security](#15-security) 2. [Use of CloudEvents Attributes](#2-use-of-cloudevents-attributes) - 2.1. [contenttype Attribute](#21-contenttype-attribute) - 2.2. [data Attribute](#22-data-attribute) 3. [RocketMQ Message Mapping](#3-rocketmq-message-mapping) - 3.1. [Binary Content Mode](#31-binary-content-mode) - 3.2. [Structured Content Mode](#32-structured-content-mode) 4. [References](#4-references) ## 1. Introduction [CloudEvents][CE] is a standardized and transport-neutral definition of the structure and metadata description of events. This specification defines how the elements defined in the CloudEvents specification are to be used in the RocketMQ Message protocol as client produced and consumed messages. ### 1.1. Conformance The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC2119. ### 1.2. Relation to RocketMQ This specification does not prescribe rules constraining transfer or settlement of event messages with RocketMQ; it solely defines how CloudEvents are expressed in the RocketMQ message transport protocol as client messages that are produced and consumed. ### 1.3. Content Modes The specification defines two content modes for transferring events: *structured* and *binary*. The RocketMQ protocol have already supported custom message headers, necessary for *binary* mode. Event metadata attributes and event data are placed into the RocketMQ message payload using an [event format](#14-event-formats). ### 1.4. Event Formats Event formats, used with the *stuctured* content mode, define how an event is expressed in a particular data format. All implementations of this specification MUST support the [JSON event format][JSON-format]. ### 1.5. Security This specification does not introduce any new security features for RocketMQ, or mandate specific existing features to be used. ## 2. Use of CloudEvents Attributes This specification does not further define any of the [CloudEvents][CE] event attributes. ### 2.1. contenttype Attribute The `contenttype` attribute is assumed to contain a media-type expression compliant with [RFC2046][RFC2046]. ### 2.2. data Attribute The `data` attribute is assumed to contain opaque application data that is encoded as declared by the `contenttype` attribute. An application is free to hold the information in any in-memory representation of its choosing, but as the value is transposed into RocketMQ as defined in this specification, core RocketMQ provides data available as a sequence of bytes. For instance, if the declared `contenttype` is `application/json;charset=utf-8`, the expectation is that the `data` attribute value is made available as [UTF-8][RFC3629] encoded JSON text. ## 3. RocketMQ Message Mapping The receiver of the event can distinguish between the two content modes by inspecting the `CE_contentType` property of the RocketMQ message. If the value is prefixed with the CloudEvents media type `application/cloudevents`, indicating the use of a known event format, the receiver uses structured mode, otherwise it defaults to binary mode. If a receiver finds a CloudEvents media type as per the above rule, but with an event format that it cannot handle, for instance `application/cloudevents+avro`, it MAY still treat the event as binary and forward it to another party as-is . ### 3.1. Binary Content Mode The [binary content mode](#31-binary-content-mode) accommodates any shape of event data, and allows for efficient transfer and without transcoding effort. #### 3.1.1. Content Type For the binary mode, the header `CE_contenttype property` MUST be mapped directly to the CloudEvents contentType attribute. #### 3.1.2. Event Data Encoding The data attribute byte-sequence MUST be used as the value of the RocketMQ message. #### 3.1.3. Metadata Headers All CloudEvents attributes and CloudEvent Attributes Extensions with exception of data MUST be individually mapped to and from the Header fields in the RocketMQ message. ##### 3.1.3.1 Property Names [CloudEvents][CE] attributes are prefixed with `"CE_"` for use in the message section. Examples: * `time` maps to `CE_time` * `id` maps to `CE_id` * `specversion` maps to `CE_specversion` ##### 3.1.3.2 Property Values The value for each RocketMQ Message header is constructed from the respective header's RocketMQ representation, compliant with the RocketMQ message format specification. #### 3.1.4 Example This example shows the binary mode mapping of an event into the RocketMQ message. All other CloudEvents attributes are mapped to RocketMQ message property fields with prefix `CE_`. Mind that `CE_` here does refer to the event data content carried in the payload. ``` text ------------------ Message ------------------- Topic: mytopic -------------- user properties --------------- CE_contenttype: application/avro CE_specversion: "0.1" CE_type: "com.example.someevent" CE_time: "2018-11-23T03:56:24Z" CE_id: "1234-1234-1234" CE_source: "/mycontext/subcontext" .... further attributes ... ------------------- value -------------------- ... application data ... ----------------------------------------------- ``` ### 3.2. Structured Content Mode The [structured content mode](#32-structured-content-mode) keeps event metadata and data together in the payload, allowing simple forwarding of the same event across multiple routing hops, and across multiple transports. #### 3.2.1. RocketMQ Content-Type The [RocketMQ][RocketMQ] `CE_contenttype` property field MUST be set to the media type of an event format. Example for the JSON format: ``` CE_contenttype: application/cloudevents+json; charset=UTF-8 ``` #### 3.2.2. Event Data Encoding The chosen event format defines how all attributes, including the payload, are represented. And in RocketMQ Message Header, it describes what is the type of transport event. The event metadata and data MAY then be rendered in accordance with the event format specification and the resulting data becomes the payload. #### 3.2.3. Metadata Headers Implementations MAY include the same RocketMQ headers as defined for the binary mode. #### 3.2.4. Example This example shows a JSON event format encoded structured data event: ``` text ------------------ Message --------------------------- Topic: mytopic ------------------ user properties ------------------- CE_contenttype: application/cloudevents+json; charset=UTF-8 ------------------ value ----------------------------- { "cloudEventsVersion" : "0.1", "eventType" : "com.example.someevent", ... further attributes omitted ... "data" : { ... application data ... } } ------------------------------------------------------ ``` ## 4. References - [RocketMQ][RocketMQ] The RocketMQ Messaging System - [RFC2046][RFC2046] Multipurpose Internet Mail Extensions (MIME) Part Two: Media Types - [RFC2119][RFC2119] Key words for use in RFCs to Indicate Requirement Levels - [RFC3629][RFC3629] UTF-8, a transformation format of ISO 10646 - [RFC7159][RFC7159] The JavaScript Object Notation (JSON) Data Interchange Format [CE]: ./spec.md [JSON-format]: ./json-format.md [RocketMQ]: http://rocketmq.apache.org/ [JSON-Value]: https://tools.ietf.org/html/rfc7159#section-3 [RFC2046]: https://tools.ietf.org/html/rfc2046 [RFC2119]: https://tools.ietf.org/html/rfc2119 [RFC3629]: https://tools.ietf.org/html/rfc3629 [RFC7159]: https://tools.ietf.org/html/rfc7159 ================================================ FILE: rocketmq-cloudevents-binding/src/main/java/org/apache/rocketmq/cloudevent/RocketMQMessageFactory.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.cloudevent; import org.apache.rocketmq.cloudevent.impl.RocketMQBinaryMessageReader; import org.apache.rocketmq.cloudevent.impl.RocketMQHeaders; import org.apache.rocketmq.cloudevent.impl.RocketMQMessageWriter; import io.cloudevents.core.message.MessageReader; import io.cloudevents.core.message.MessageWriter; import io.cloudevents.core.message.impl.GenericStructuredMessageReader; import io.cloudevents.core.message.impl.MessageUtils; import io.cloudevents.lang.Nullable; import io.cloudevents.rw.CloudEventRWException; import io.cloudevents.rw.CloudEventWriter; import org.apache.rocketmq.common.message.Message; import javax.annotation.ParametersAreNonnullByDefault; import java.util.Map; @ParametersAreNonnullByDefault public final class RocketMQMessageFactory { private RocketMQMessageFactory() { // prevent instantiation } public static MessageReader createReader(final Message message) throws CloudEventRWException { return createReader(message.getProperties(), message.getBody()); } public static MessageReader createReader(final Map props, @Nullable final byte[] body) throws CloudEventRWException { return MessageUtils.parseStructuredOrBinaryMessage( () -> props.get(RocketMQHeaders.CONTENT_TYPE), format -> new GenericStructuredMessageReader(format, body), () -> props.get(RocketMQHeaders.SPEC_VERSION), sv -> new RocketMQBinaryMessageReader(sv, props, body) ); } public static MessageWriter, Message> createWriter(String topic) { return new RocketMQMessageWriter<>(topic); } public static MessageWriter, Message> createWriter(String topic, String keys) { return new RocketMQMessageWriter<>(topic, keys); } public static MessageWriter, Message> createWriter(String topic, String keys, String tags) { return new RocketMQMessageWriter<>(topic, keys, tags); } } ================================================ FILE: rocketmq-cloudevents-binding/src/main/java/org/apache/rocketmq/cloudevent/impl/RocketMQBinaryMessageReader.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.cloudevent.impl; import io.cloudevents.SpecVersion; import io.cloudevents.core.data.BytesCloudEventData; import io.cloudevents.core.message.impl.BaseGenericBinaryMessageReaderImpl; import java.util.Map; import java.util.Objects; import java.util.function.BiConsumer; public class RocketMQBinaryMessageReader extends BaseGenericBinaryMessageReaderImpl { private final Map headers; public RocketMQBinaryMessageReader(SpecVersion version, Map headers, byte[] payload) { super(version, payload != null && payload.length > 0 ? BytesCloudEventData.wrap(payload) : null); Objects.requireNonNull(headers); this.headers = headers; } @Override protected boolean isContentTypeHeader(String key) { return key.equals(RocketMQHeaders.CONTENT_TYPE); } @Override protected boolean isCloudEventsHeader(String key) { return key.length() > 3 && key.substring(0, RocketMQHeaders.CE_PREFIX.length()).startsWith(RocketMQHeaders.CE_PREFIX); } @Override protected String toCloudEventsKey(String key) { return key.substring(RocketMQHeaders.CE_PREFIX.length()).toLowerCase(); } @Override protected void forEachHeader(BiConsumer fn) { this.headers.forEach((k, v) -> fn.accept(k, v)); } @Override protected String toCloudEventsValue(String value) { return value; } } ================================================ FILE: rocketmq-cloudevents-binding/src/main/java/org/apache/rocketmq/cloudevent/impl/RocketMQHeaders.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.cloudevent.impl; import io.cloudevents.core.message.impl.MessageUtils; import io.cloudevents.core.v1.CloudEventV1; import java.util.Map; public class RocketMQHeaders { public static final String CE_PREFIX = "CE_"; protected static final Map ATTRIBUTES_TO_HEADERS = MessageUtils.generateAttributesToHeadersMapping(v -> CE_PREFIX + v); public static final String CONTENT_TYPE = ATTRIBUTES_TO_HEADERS.get(CloudEventV1.DATACONTENTTYPE); public static final String SPEC_VERSION = ATTRIBUTES_TO_HEADERS.get(CloudEventV1.SPECVERSION); } ================================================ FILE: rocketmq-cloudevents-binding/src/main/java/org/apache/rocketmq/cloudevent/impl/RocketMQMessageWriter.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.cloudevent.impl; import io.cloudevents.CloudEventData; import io.cloudevents.SpecVersion; import io.cloudevents.core.format.EventFormat; import io.cloudevents.core.message.MessageWriter; import io.cloudevents.rw.CloudEventContextWriter; import io.cloudevents.rw.CloudEventRWException; import io.cloudevents.rw.CloudEventWriter; import org.apache.rocketmq.common.message.Message; public final class RocketMQMessageWriter implements MessageWriter, Message>, CloudEventWriter { private Message message; public RocketMQMessageWriter(String topic) { message = new Message(); message.setTopic(topic); } public RocketMQMessageWriter(String topic, String keys) { message = new Message(); message.setTopic(topic); if (keys != null && keys.length() > 0) { message.setKeys(keys); } } public RocketMQMessageWriter(String topic, String keys, String tags) { message = new Message(); message.setTopic(topic); if (tags != null && tags.length() > 0) { message.setTags(tags); } if (keys != null && keys.length() > 0) { message.setKeys(keys); } } @Override public CloudEventContextWriter withContextAttribute(String name, String value) throws CloudEventRWException { String propName = RocketMQHeaders.ATTRIBUTES_TO_HEADERS.get(name); if (propName == null) { propName = RocketMQHeaders.CE_PREFIX + name; } message.putUserProperty(propName, value); return this; } @Override public RocketMQMessageWriter create(final SpecVersion version) { message.putUserProperty(RocketMQHeaders.SPEC_VERSION, version.toString()); return this; } @Override public Message setEvent(final EventFormat format, final byte[] value) throws CloudEventRWException { message.putUserProperty(RocketMQHeaders.CONTENT_TYPE, format.serializedContentType()); message.setBody(value); return message; } @Override public Message end(final CloudEventData data) throws CloudEventRWException { message.setBody(data.toBytes()); return message; } @Override public Message end() { message.setBody(null); return message; } } ================================================ FILE: rocketmq-cloudevents-binding/src/test/java/org/apache/rocketmq/cloudevent/RocketMQMessageWriterTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.cloudevent; import io.cloudevents.CloudEvent; import io.cloudevents.SpecVersion; import io.cloudevents.core.message.StructuredMessageReader; import io.cloudevents.core.mock.CSVFormat; import io.cloudevents.core.test.Data; import io.cloudevents.core.v03.CloudEventV03; import io.cloudevents.core.v1.CloudEventV1; import io.cloudevents.types.Time; import org.apache.rocketmq.cloudevent.impl.RocketMQHeaders; import org.apache.rocketmq.common.message.Message; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import java.util.AbstractMap; import java.util.Map; import java.util.stream.Collectors; import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; public class RocketMQMessageWriterTest { private static final String PREFIX_TEMPLATE = RocketMQHeaders.CE_PREFIX + "%s"; private static final String DATACONTENTTYPE_NULL = null; private static final byte[] DATAPAYLOAD_NULL = null; @ParameterizedTest @MethodSource("io.cloudevents.core.test.Data#allEventsWithoutExtensions") void testRequestWithStructured(CloudEvent event) { String expectedContentType = CSVFormat.INSTANCE.serializedContentType(); byte[] expectedBuffer = CSVFormat.INSTANCE.serialize(event); String topic = "test"; String keys = "keys"; String tags = "tags"; Message message = StructuredMessageReader .from(event, CSVFormat.INSTANCE) .read(RocketMQMessageFactory.createWriter(topic, keys, tags)); assertThat(message.getTopic()) .isEqualTo(topic); assertThat(message.getKeys()) .isEqualTo(keys); assertThat(message.getTags()) .isEqualTo(tags); assertThat(message.getBody()) .isEqualTo(expectedBuffer); } @ParameterizedTest @MethodSource("binaryTestArguments") void testRequestWithBinary(CloudEvent event, Map expectedHeaders, byte[] expectedBody) { String topic = "test"; String keys = "keys"; String tags = "tags"; Message message = RocketMQMessageFactory .createWriter(topic, keys, tags) .writeBinary(event); assertThat(message.getTopic()) .isEqualTo(topic); assertThat(message.getKeys()) .isEqualTo(keys); assertThat(message.getTags()) .isEqualTo(tags); assertThat(message.getBody()) .isEqualTo(expectedBody); assertThat(message.getProperties() .keySet().containsAll(expectedHeaders.keySet())); assertThat(message.getProperties() .values().containsAll(expectedHeaders.values())); } private static Stream binaryTestArguments() { return Stream.of( // V03 Arguments.of( Data.V03_MIN, properties( property(CloudEventV03.SPECVERSION, SpecVersion.V03.toString()), property(CloudEventV03.ID, Data.ID), property(CloudEventV03.TYPE, Data.TYPE), property(CloudEventV03.SOURCE, Data.SOURCE.toString()), property("ignored", "ignore") ), DATAPAYLOAD_NULL ), Arguments.of( Data.V03_WITH_JSON_DATA, properties( property(CloudEventV03.SPECVERSION, SpecVersion.V03.toString()), property(CloudEventV03.ID, Data.ID), property(CloudEventV03.TYPE, Data.TYPE), property(CloudEventV03.SOURCE, Data.SOURCE.toString()), property(CloudEventV03.SCHEMAURL, Data.DATASCHEMA.toString()), property(CloudEventV03.SUBJECT, Data.SUBJECT), property(CloudEventV03.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignore") ), Data.DATA_JSON_SERIALIZED ), Arguments.of( Data.V03_WITH_JSON_DATA_WITH_EXT_STRING, properties( property(CloudEventV03.SPECVERSION, SpecVersion.V03.toString()), property(CloudEventV03.ID, Data.ID), property(CloudEventV03.TYPE, Data.TYPE), property(CloudEventV03.SOURCE, Data.SOURCE.toString()), property(CloudEventV03.SCHEMAURL, Data.DATASCHEMA.toString()), property(CloudEventV03.SUBJECT, Data.SUBJECT), property(CloudEventV03.TIME, Time.writeTime(Data.TIME)), property("astring", "aaa"), property("aboolean", "true"), property("anumber", "10"), property("ignored", "ignored") ), Data.DATA_JSON_SERIALIZED ), Arguments.of( Data.V03_WITH_XML_DATA, properties( property(CloudEventV03.SPECVERSION, SpecVersion.V03.toString()), property(CloudEventV03.ID, Data.ID), property(CloudEventV03.TYPE, Data.TYPE), property(CloudEventV03.SOURCE, Data.SOURCE.toString()), property(CloudEventV03.SUBJECT, Data.SUBJECT), property(CloudEventV03.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignored") ), Data.DATA_XML_SERIALIZED ), Arguments.of( Data.V03_WITH_TEXT_DATA, properties( property(CloudEventV03.SPECVERSION, SpecVersion.V03.toString()), property(CloudEventV03.ID, Data.ID), property(CloudEventV03.TYPE, Data.TYPE), property(CloudEventV03.SOURCE, Data.SOURCE.toString()), property(CloudEventV03.SUBJECT, Data.SUBJECT), property(CloudEventV03.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignored") ), Data.DATA_TEXT_SERIALIZED ), // V1 Arguments.of( Data.V1_MIN, properties( property(CloudEventV1.SPECVERSION, SpecVersion.V1.toString()), property(CloudEventV1.ID, Data.ID), property(CloudEventV1.TYPE, Data.TYPE), property(CloudEventV1.SOURCE, Data.SOURCE.toString()), property("ignored", "ignored") ), DATAPAYLOAD_NULL ), Arguments.of( Data.V1_WITH_JSON_DATA, properties( property(CloudEventV1.SPECVERSION, SpecVersion.V1.toString()), property(CloudEventV1.ID, Data.ID), property(CloudEventV1.TYPE, Data.TYPE), property(CloudEventV1.SOURCE, Data.SOURCE.toString()), property(CloudEventV1.DATASCHEMA, Data.DATASCHEMA.toString()), property(CloudEventV1.SUBJECT, Data.SUBJECT), property(CloudEventV1.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignored") ), Data.DATA_JSON_SERIALIZED ), Arguments.of( Data.V1_WITH_JSON_DATA_WITH_EXT_STRING, properties( property(CloudEventV1.SPECVERSION, SpecVersion.V1.toString()), property(CloudEventV1.ID, Data.ID), property(CloudEventV1.TYPE, Data.TYPE), property(CloudEventV1.SOURCE, Data.SOURCE.toString()), property(CloudEventV1.DATASCHEMA, Data.DATASCHEMA.toString()), property(CloudEventV1.SUBJECT, Data.SUBJECT), property(CloudEventV1.TIME, Time.writeTime(Data.TIME)), property("astring", "aaa"), property("aboolean", "true"), property("anumber", "10"), property("ignored", "ignored") ), Data.DATA_JSON_SERIALIZED ), Arguments.of( Data.V1_WITH_XML_DATA, properties( property(CloudEventV1.SPECVERSION, SpecVersion.V1.toString()), property(CloudEventV1.ID, Data.ID), property(CloudEventV1.TYPE, Data.TYPE), property(CloudEventV1.SOURCE, Data.SOURCE.toString()), property(CloudEventV1.SUBJECT, Data.SUBJECT), property(CloudEventV1.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignored") ), Data.DATA_XML_SERIALIZED ), Arguments.of( Data.V1_WITH_TEXT_DATA, properties( property(CloudEventV1.SPECVERSION, SpecVersion.V1.toString()), property(CloudEventV1.ID, Data.ID), property(CloudEventV1.TYPE, Data.TYPE), property(CloudEventV1.SOURCE, Data.SOURCE.toString()), property(CloudEventV1.SUBJECT, Data.SUBJECT), property(CloudEventV1.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignored") ), Data.DATA_TEXT_SERIALIZED ) ); } private static final AbstractMap.SimpleEntry property(final String name, final String value) { return name.equalsIgnoreCase("ignored") ? new AbstractMap.SimpleEntry<>(name, value) : new AbstractMap.SimpleEntry<>(String.format(PREFIX_TEMPLATE, name), value); } @SafeVarargs private static final Map properties(final AbstractMap.SimpleEntry... entries) { return Stream.of(entries) .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue)); } } ================================================ FILE: rocketmq-cloudevents-binding/src/test/java/org/apache/rocketmq/cloudevent/RocketmqMessageFactoryTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.cloudevent; import io.cloudevents.CloudEvent; import io.cloudevents.SpecVersion; import io.cloudevents.core.message.Encoding; import io.cloudevents.core.message.MessageReader; import io.cloudevents.core.mock.CSVFormat; import io.cloudevents.core.test.Data; import io.cloudevents.core.v03.CloudEventV03; import io.cloudevents.core.v1.CloudEventV1; import io.cloudevents.types.Time; import org.apache.rocketmq.cloudevent.impl.RocketMQHeaders; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import java.util.AbstractMap; import java.util.HashMap; import java.util.Map; import java.util.stream.Collectors; import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; public class RocketmqMessageFactoryTest { private static final String PREFIX_TEMPLATE = RocketMQHeaders.CE_PREFIX + "%s"; private static final String DATACONTENTTYPE_NULL = null; private static final byte[] DATAPAYLOAD_NULL = null; @ParameterizedTest() @MethodSource("binaryTestArguments") public void readBinary(final Map props, final String contentType, final byte[] body, final CloudEvent event) { props.put(RocketMQHeaders.CONTENT_TYPE, contentType); final MessageReader reader = RocketMQMessageFactory.createReader(props, body); assertThat(reader.getEncoding()).isEqualTo(Encoding.BINARY); assertThat(reader.toEvent()).isEqualTo(event); } @ParameterizedTest() @MethodSource("io.cloudevents.core.test.Data#allEventsWithoutExtensions") public void readStructured(final CloudEvent event) { final String contentType = CSVFormat.INSTANCE.serializedContentType() + "; charset=utf8"; final byte[] contentPayload = CSVFormat.INSTANCE.serialize(event); Map properties = new HashMap<>(); properties.put(RocketMQHeaders.CONTENT_TYPE, contentType); final MessageReader reader = RocketMQMessageFactory.createReader(properties, contentPayload); assertThat(reader.getEncoding()).isEqualTo(Encoding.STRUCTURED); assertThat(reader.toEvent()).isEqualTo(event); } private static Stream binaryTestArguments() { return Stream.of( // V03 Arguments.of( properties( property(CloudEventV03.SPECVERSION, SpecVersion.V03.toString()), property(CloudEventV03.ID, Data.ID), property(CloudEventV03.TYPE, Data.TYPE), property(CloudEventV03.SOURCE, Data.SOURCE.toString()), property("ignored", "ignore") ), DATACONTENTTYPE_NULL, DATAPAYLOAD_NULL, Data.V03_MIN ), Arguments.of( properties( property(CloudEventV03.SPECVERSION, SpecVersion.V03.toString()), property(CloudEventV03.ID, Data.ID), property(CloudEventV03.TYPE, Data.TYPE), property(CloudEventV03.SOURCE, Data.SOURCE.toString()), property(CloudEventV03.SCHEMAURL, Data.DATASCHEMA.toString()), property(CloudEventV03.SUBJECT, Data.SUBJECT), property(CloudEventV03.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignore") ), Data.DATACONTENTTYPE_JSON, Data.DATA_JSON_SERIALIZED, Data.V03_WITH_JSON_DATA ), Arguments.of( properties( property(CloudEventV03.SPECVERSION, SpecVersion.V03.toString()), property(CloudEventV03.ID, Data.ID), property(CloudEventV03.TYPE, Data.TYPE), property(CloudEventV03.SOURCE, Data.SOURCE.toString()), property(CloudEventV03.SCHEMAURL, Data.DATASCHEMA.toString()), property(CloudEventV03.SUBJECT, Data.SUBJECT), property(CloudEventV03.TIME, Time.writeTime(Data.TIME)), property("astring", "aaa"), property("aboolean", "true"), property("anumber", "10"), property("ignored", "ignored") ), Data.DATACONTENTTYPE_JSON, Data.DATA_JSON_SERIALIZED, Data.V03_WITH_JSON_DATA_WITH_EXT_STRING ), Arguments.of( properties( property(CloudEventV03.SPECVERSION, SpecVersion.V03.toString()), property(CloudEventV03.ID, Data.ID), property(CloudEventV03.TYPE, Data.TYPE), property(CloudEventV03.SOURCE, Data.SOURCE.toString()), property(CloudEventV03.SUBJECT, Data.SUBJECT), property(CloudEventV03.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignored") ), Data.DATACONTENTTYPE_XML, Data.DATA_XML_SERIALIZED, Data.V03_WITH_XML_DATA ), Arguments.of( properties( property(CloudEventV03.SPECVERSION, SpecVersion.V03.toString()), property(CloudEventV03.ID, Data.ID), property(CloudEventV03.TYPE, Data.TYPE), property(CloudEventV03.SOURCE, Data.SOURCE.toString()), property(CloudEventV03.SUBJECT, Data.SUBJECT), property(CloudEventV03.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignored") ), Data.DATACONTENTTYPE_TEXT, Data.DATA_TEXT_SERIALIZED, Data.V03_WITH_TEXT_DATA ), // V1 Arguments.of( properties( property(CloudEventV1.SPECVERSION, SpecVersion.V1.toString()), property(CloudEventV1.ID, Data.ID), property(CloudEventV1.TYPE, Data.TYPE), property(CloudEventV1.SOURCE, Data.SOURCE.toString()), property("ignored", "ignored") ), DATACONTENTTYPE_NULL, DATAPAYLOAD_NULL, Data.V1_MIN ), Arguments.of( properties( property(CloudEventV1.SPECVERSION, SpecVersion.V1.toString()), property(CloudEventV1.ID, Data.ID), property(CloudEventV1.TYPE, Data.TYPE), property(CloudEventV1.SOURCE, Data.SOURCE.toString()), property(CloudEventV1.DATASCHEMA, Data.DATASCHEMA.toString()), property(CloudEventV1.SUBJECT, Data.SUBJECT), property(CloudEventV1.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignored") ), Data.DATACONTENTTYPE_JSON, Data.DATA_JSON_SERIALIZED, Data.V1_WITH_JSON_DATA ), Arguments.of( properties( property(CloudEventV1.SPECVERSION, SpecVersion.V1.toString()), property(CloudEventV1.ID, Data.ID), property(CloudEventV1.TYPE, Data.TYPE), property(CloudEventV1.SOURCE, Data.SOURCE.toString()), property(CloudEventV1.DATASCHEMA, Data.DATASCHEMA.toString()), property(CloudEventV1.SUBJECT, Data.SUBJECT), property(CloudEventV1.TIME, Time.writeTime(Data.TIME)), property("astring", "aaa"), property("aboolean", "true"), property("anumber", "10"), property("ignored", "ignored") ), Data.DATACONTENTTYPE_JSON, Data.DATA_JSON_SERIALIZED, Data.V1_WITH_JSON_DATA_WITH_EXT_STRING ), Arguments.of( properties( property(CloudEventV1.SPECVERSION, SpecVersion.V1.toString()), property(CloudEventV1.ID, Data.ID), property(CloudEventV1.TYPE, Data.TYPE), property(CloudEventV1.SOURCE, Data.SOURCE.toString()), property(CloudEventV1.SUBJECT, Data.SUBJECT), property(CloudEventV1.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignored") ), Data.DATACONTENTTYPE_XML, Data.DATA_XML_SERIALIZED, Data.V1_WITH_XML_DATA ), Arguments.of( properties( property(CloudEventV1.SPECVERSION, SpecVersion.V1.toString()), property(CloudEventV1.ID, Data.ID), property(CloudEventV1.TYPE, Data.TYPE), property(CloudEventV1.SOURCE, Data.SOURCE.toString()), property(CloudEventV1.SUBJECT, Data.SUBJECT), property(CloudEventV1.TIME, Time.writeTime(Data.TIME)), property("ignored", "ignored") ), Data.DATACONTENTTYPE_TEXT, Data.DATA_TEXT_SERIALIZED, Data.V1_WITH_TEXT_DATA ) ); } private static final AbstractMap.SimpleEntry property(final String name, final String value) { return name.equalsIgnoreCase("ignored") ? new AbstractMap.SimpleEntry<>(name, value) : new AbstractMap.SimpleEntry<>(String.format(PREFIX_TEMPLATE, name), value); } @SafeVarargs private static final Map properties(final AbstractMap.SimpleEntry... entries) { return Stream.of(entries) .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue)); } } ================================================ FILE: rocketmq-flume/.gitignore ================================================ .* *.class *.jar *.war *.iml .settings target !.gitignore ================================================ FILE: rocketmq-flume/LICENSE ================================================ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (properties) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] 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. ================================================ FILE: rocketmq-flume/LICENSE-BIN ================================================ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (properties) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] 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. ================================================ FILE: rocketmq-flume/NOTICE ================================================ Apache RocketMQ (incubating) Copyright 2016-2017 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). ================================================ FILE: rocketmq-flume/NOTICE-BIN ================================================ Apache RocketMQ (incubating) Copyright 2016-2017 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). ------ This product has a bundle Flume: Apache Flume Copyright 2012 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). Portions of this software were developed at Cloudera, Inc. (http://www.cloudera.com/). ================================================ FILE: rocketmq-flume/README.md ================================================ rocketmq-flume-ng Sink & Source ========================== This project is used to receive and send messages between [RocketMQ](http://rocketmq.incubator.apache.org/) and [Flume-ng](https://github.com/apache/flume) 1. Firstly, please get familiar with [RocketMQ](http://rocketmq.incubator.apache.org/) and [Flume-ng](https://github.com/apache/flume). 2. Ensure that the jar related to [RocketMQ](http://rocketmq.incubator.apache.org/dowloading/releases) exists in local maven repository. 3. Execute the following command in rocketmq-flume root directory `mvn clean install dependency:copy-dependencies` 4. Copy the jar depended by rocketmq-flume to `$FLUME_HOME/lib`(the specific jar will be given later) ## Sink ### Sink configuration instruction | key | nullable | default |description| |---------------|----------|------------------------|-----------| | nameserver | false | |nameserver address| | topic | true | "FLUME_TOPIC" |topic name| | tag | true | "FLUME_TAG" |tag name| | producerGroup | true | "FLUME_PRODUCER_GROUP" |producerGroup name| | batchSize | true | 1 |max batch event taking num| | maxProcessTime| true | 1000 |max batch event taking time,default is 1s| ### Sink example - Write the Flume configuration file ``` agent1.sources=source1 agent1.channels=channel1 agent1.sinks=sink1 agent1.sources.source1.type=avro agent1.sources.source1.bind=0.0.0.0 agent1.sources.source1.port=15151 agent1.sources.source1.channels=channel1 agent1.sinks.sink1.type=org.apache.rocketmq.flume.ng.sink.RocketMQSink agent1.sinks.sink1.nameserver=x.x.x.x:9876 agent1.sinks.sink1.channel=channel1 agent1.channels.channel1.type=memory agent1.channels.channel1.capacity=100 agent1.channels.channel1.transactionCapacity=100 agent1.channels.channel1.keep-alive=3 ``` - Copy the jars below to `$FLUME_HOME/lib` ``` rocketmq-flume-sink-0.0.2-SNAPSHOT.jar (path: $PROJECT_HOME/rocketmq-flume-sink/target) fastjson-1.2.12.jar (path: $PROJECT_HOME/rocketmq-flume-sink/target/dependency) netty-all-4.0.36.Final.jar (path: $PROJECT_HOME/rocketmq-flume-sink/target/dependency) rocketmq-client-4.0.0-incubating.jar (path: $PROJECT_HOME/rocketmq-flume-sink/target/dependency) rocketmq-common-4.0.0-incubating.jar (path: $PROJECT_HOME/rocketmq-flume-sink/target/dependency) rocketmq-remoting-4.0.0-incubating.jar (path: $PROJECT_HOME/rocketmq-flume-sink/target/dependency) ``` - Execute the command and check the console output ``` shell1> $FLUME_HOME/bin/flume-ng agent -c conf -f conf/flume.conf -n agent1 -Dflume.root.logger=INFO,console shell2> $FLUME_HOME/bin/flume-ng avro-client -H localhost -p 15151 -F $FLUME_HOME/README ``` ## Source ### Source configuration instruction | key | nullable | default |description| |---------------|----------|----------------------|-----------| | nameserver | false | |nameserver address| | topic | true |"FLUME_TOPIC" |topic name| | tag | true |"FLUME_TAG" |tag name| | consumerGroup | true |"FLUME_CONSUMER_GROUP"|consumerGroup name| | messageModel | true | "BROADCASTING" |RocketMQ message model,"BROADCASTING" or "CLUSTERING"| | batchSize | true | 32 |batch consuming messages from RocketMq max num| ### Source example - Write the Flume configuration file ``` agent1.sources=source1 agent1.channels=channel1 agent1.sinks=sink1 agent1.sources.source1.type=org.apache.rocketmq.flume.ng.source.RocketMQSource agent1.sources.source1.nameserver=x.x.x.x:9876 agent1.sources.source1.channels=channel1 agent1.sinks.sink1.type=logger agent1.sinks.sink1.channel=channel1 agent1.channels.channel1.type=memory agent1.channels.channel1.capacity=100 agent1.channels.channel1.transactionCapacity=100 agent1.channels.channel1.keep-alive=3 ``` - Copy the jars below to `$FLUME_HOME/lib` ``` rocketmq-flume-source-0.0.2-SNAPSHOT.jar (path: $PROJECT_HOME/rocketmq-flume-source/target) fastjson-1.2.12.jar (path: $PROJECT_HOME/rocketmq-flume-sink/target/dependency) netty-all-4.0.36.Final.jar (path: $PROJECT_HOME/rocketmq-flume-sink/target/dependency) rocketmq-client-4.0.0-incubating.jar (path: $PROJECT_HOME/rocketmq-flume-sink/target/dependency) rocketmq-common-4.0.0-incubating.jar (path: $PROJECT_HOME/rocketmq-flume-sink/target/dependency) rocketmq-remoting-4.0.0-incubating.jar (path: $PROJECT_HOME/rocketmq-flume-sink/target/dependency) ``` - Send some test message to RocketMQ - Execute the command and check the console output ``` $FLUME_HOME/bin/flume-ng agent -c conf -f conf/flume.conf -n agent1 -Dflume.root.logger=INFO,console ``` ================================================ FILE: rocketmq-flume/pom.xml ================================================ 4.0.0 org.apache rocketmq-flume 0.0.2-SNAPSHOT rocketmq-flume rocketmq-flume-sink rocketmq-flume-source UTF-8 false true 1.7 1.7 1.8.0 4.7.0 org.apache.rocketmq rocketmq-client ${rocketmq.version} org.apache.flume flume-ng-core ${flume.version} junit junit test 4.12 org.apache.rocketmq rocketmq-namesrv ${rocketmq.version} test ch.qos.logback logback-classic org.apache.rocketmq rocketmq-broker ${rocketmq.version} test ch.qos.logback logback-classic io.netty netty-tcnative maven-compiler-plugin 3.5.1 ${maven.compiler.source} ${maven.compiler.target} ${maven.compiler.source} true true org.apache.rat apache-rat-plugin 0.12 README.md maven-checkstyle-plugin 2.17 verify verify style/rmq_checkstyle.xml UTF-8 true true false false check src/main/resources true pom ================================================ FILE: rocketmq-flume/rocketmq-flume-sink/pom.xml ================================================ 4.0.0 org.apache rocketmq-flume 0.0.2-SNAPSHOT rocketmq-flume-sink ================================================ FILE: rocketmq-flume/rocketmq-flume-sink/src/main/java/org/apache/rocketmq/flume/ng/sink/RocketMQSink.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.flume.ng.sink; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.client.producer.DefaultMQProducer; import org.apache.rocketmq.client.producer.SendCallback; import org.apache.rocketmq.client.producer.SendResult; import org.apache.rocketmq.common.message.Message; import java.io.UnsupportedEncodingException; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.atomic.AtomicInteger; import org.apache.flume.Channel; import org.apache.flume.Context; import org.apache.flume.Event; import org.apache.flume.EventDeliveryException; import org.apache.flume.FlumeException; import org.apache.flume.Transaction; import org.apache.flume.conf.Configurable; import org.apache.flume.conf.ConfigurationException; import org.apache.flume.instrumentation.SinkCounter; import org.apache.flume.sink.AbstractSink; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.BATCH_SIZE_CONFIG; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.BATCH_SIZE_DEFAULT; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.MAX_PROCESS_TIME_CONFIG; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.MAX_PROCESS_TIME_DEFAULT; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.NAME_SERVER_CONFIG; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.PRODUCER_GROUP_CONFIG; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.PRODUCER_GROUP_DEFAULT; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.TAG_CONFIG; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.TAG_DEFAULT; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.TOPIC_CONFIG; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.TOPIC_DEFAULT; /** * */ public class RocketMQSink extends AbstractSink implements Configurable { private static final Logger log = LoggerFactory.getLogger(RocketMQSink.class); private String nameServer; private String topic; private String tag; private String producerGroup; private int batchSize; private long maxProcessTime; /** Monitoring counter. */ private SinkCounter sinkCounter; private DefaultMQProducer producer; @Override public void configure(Context context) { nameServer = context.getString(NAME_SERVER_CONFIG); if (nameServer == null) { throw new ConfigurationException("NameServer must not be null"); } topic = context.getString(TOPIC_CONFIG, TOPIC_DEFAULT); tag = context.getString(TAG_CONFIG, TAG_DEFAULT); producerGroup = context.getString(PRODUCER_GROUP_CONFIG, PRODUCER_GROUP_DEFAULT); batchSize = context.getInteger(BATCH_SIZE_CONFIG, BATCH_SIZE_DEFAULT); maxProcessTime = context.getLong(MAX_PROCESS_TIME_CONFIG, MAX_PROCESS_TIME_DEFAULT); if (sinkCounter == null) { sinkCounter = new SinkCounter(getName()); } } @Override public synchronized void start() { producer = new DefaultMQProducer(producerGroup); producer.setNamesrvAddr(nameServer); try { producer.start(); } catch (MQClientException e) { sinkCounter.incrementConnectionFailedCount(); log.error("RocketMQ producer start failed", e); throw new FlumeException("Failed to start RocketMQ producer", e); } sinkCounter.incrementConnectionCreatedCount(); sinkCounter.start(); super.start(); } @Override public Status process() throws EventDeliveryException { Channel channel = getChannel(); Transaction transaction = null; try { transaction = channel.getTransaction(); transaction.begin(); /* batch take */ List events = new ArrayList<>(); long beginTime = System.currentTimeMillis(); while (true) { Event event = channel.take(); if (event != null) { events.add(event); } if (events.size() == batchSize || System.currentTimeMillis() - beginTime > maxProcessTime) { break; } } if (events.size() == 0) { sinkCounter.incrementBatchEmptyCount(); transaction.rollback(); return Status.BACKOFF; } /* async send */ CountDownLatch latch = new CountDownLatch(events.size()); AtomicInteger errorNum = new AtomicInteger(); for (Event event : events) { byte[] body = event.getBody(); Message message = new Message(topic, tag, body); if (log.isDebugEnabled()) { log.debug("Processing event,body={}", new String(body, "UTF-8")); } producer.send(message, new SendCallBackHandler(message, latch, errorNum)); } latch.await(); sinkCounter.addToEventDrainAttemptCount(events.size()); if (errorNum.get() > 0) { log.error("errorNum=" + errorNum + ",transaction will rollback"); transaction.rollback(); return Status.BACKOFF; } else { transaction.commit(); sinkCounter.addToEventDrainSuccessCount(events.size()); return Status.READY; } } catch (Throwable e) { log.error("Failed to processing event", e); if (transaction != null) { try { transaction.rollback(); } catch (Throwable ex) { log.error("Failed to rollback transaction", ex); throw new EventDeliveryException("Failed to rollback transaction", ex); } } return Status.BACKOFF; } finally { if (transaction != null) { transaction.close(); } } } @Override public synchronized void stop() { producer.shutdown(); sinkCounter.incrementConnectionClosedCount(); sinkCounter.stop(); super.stop(); } public class SendCallBackHandler implements SendCallback { private final Message message; private final CountDownLatch latch; private final AtomicInteger errorNum; SendCallBackHandler(Message message, CountDownLatch latch, AtomicInteger errorNum) { this.message = message; this.latch = latch; this.errorNum = errorNum; } @Override public void onSuccess(SendResult sendResult) { latch.countDown(); if (log.isDebugEnabled()) { try { log.debug("Sent event,body={},sendResult={}", new String(message.getBody(), "UTF-8"), sendResult); } catch (UnsupportedEncodingException e) { log.error("Encoding error", e); } } } @Override public void onException(Throwable e) { latch.countDown(); errorNum.incrementAndGet(); try { log.error("Message publish failed,body=" + new String(message.getBody(), "UTF-8"), e); } catch (UnsupportedEncodingException e1) { log.error("Encoding error", e); } } } } ================================================ FILE: rocketmq-flume/rocketmq-flume-sink/src/main/java/org/apache/rocketmq/flume/ng/sink/RocketMQSinkConstants.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.flume.ng.sink; /** * */ public class RocketMQSinkConstants { public static final String NAME_SERVER_CONFIG = "nameserver"; public static final String TOPIC_CONFIG = "topic"; public static final String TOPIC_DEFAULT = "FLUME_TOPIC"; public static final String TAG_CONFIG = "tag"; public static final String TAG_DEFAULT = "FLUME_TAG"; public static final String PRODUCER_GROUP_CONFIG = "producerGroup"; public static final String PRODUCER_GROUP_DEFAULT = "FLUME_PRODUCER_GROUP"; public static final String BATCH_SIZE_CONFIG = "batchSize"; public static final int BATCH_SIZE_DEFAULT = 1; public static final String MAX_PROCESS_TIME_CONFIG = "maxProcessTime"; public static final long MAX_PROCESS_TIME_DEFAULT = 1000; } ================================================ FILE: rocketmq-flume/rocketmq-flume-sink/src/test/java/org/apache/rocketmq/flume/ng/sink/RocketMQSinkTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.flume.ng.sink; import org.apache.rocketmq.broker.BrokerController; import org.apache.rocketmq.client.consumer.DefaultMQPullConsumer; import org.apache.rocketmq.client.consumer.PullResult; import org.apache.rocketmq.client.consumer.PullStatus; import org.apache.rocketmq.client.exception.MQBrokerException; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.common.BrokerConfig; import org.apache.rocketmq.common.MQVersion; import org.apache.rocketmq.common.MixAll; import org.apache.rocketmq.common.message.MessageExt; import org.apache.rocketmq.common.message.MessageQueue; import org.apache.rocketmq.common.namesrv.NamesrvConfig; import org.apache.rocketmq.common.protocol.heartbeat.MessageModel; import org.apache.rocketmq.namesrv.NamesrvController; import org.apache.rocketmq.remoting.exception.RemotingException; import java.io.UnsupportedEncodingException; import java.util.Date; import java.util.HashMap; import java.util.Map; import java.util.Random; import java.util.Set; import org.apache.commons.lang.time.DateFormatUtils; import org.apache.flume.Context; import org.apache.flume.Event; import org.apache.flume.EventDeliveryException; import org.apache.flume.Sink; import org.apache.flume.Transaction; import org.apache.flume.channel.MemoryChannel; import org.apache.flume.conf.Configurables; import org.apache.flume.event.EventBuilder; import org.apache.rocketmq.remoting.netty.NettyClientConfig; import org.apache.rocketmq.remoting.netty.NettyServerConfig; import org.apache.rocketmq.remoting.protocol.RemotingCommand; import org.apache.rocketmq.store.config.MessageStoreConfig; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; import org.slf4j.Logger; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.BATCH_SIZE_CONFIG; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.NAME_SERVER_CONFIG; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.TAG_CONFIG; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.TAG_DEFAULT; import static org.apache.rocketmq.flume.ng.sink.RocketMQSinkConstants.TOPIC_DEFAULT; import static org.junit.Assert.assertEquals; import static org.junit.Assert.fail; /** * */ public class RocketMQSinkTest { private static final Logger log = org.slf4j.LoggerFactory.getLogger(RocketMQSinkTest.class); private static String nameServer = "localhost:9876"; private static NamesrvController namesrvController; private static BrokerController brokerController; private DefaultMQPullConsumer consumer; private String tag = TAG_DEFAULT + "_SINK_TEST_" + new Random().nextInt(99); private String consumerGroup = "CONSUMER_GROUP_SINK_TEST"; private int batchSize = 100; @BeforeClass public static void startMQ() throws Exception { /* start nameserver */ startNamesrv(); /* start broker */ startBroker(); Thread.sleep(2000); } private static void startNamesrv() throws Exception { NamesrvConfig namesrvConfig = new NamesrvConfig(); NettyServerConfig nettyServerConfig = new NettyServerConfig(); nettyServerConfig.setListenPort(9876); namesrvController = new NamesrvController(namesrvConfig, nettyServerConfig); boolean initResult = namesrvController.initialize(); if (!initResult) { namesrvController.shutdown(); throw new Exception(); } namesrvController.start(); } private static void startBroker() throws Exception { System.setProperty(RemotingCommand.REMOTING_VERSION_KEY, Integer.toString(MQVersion.CURRENT_VERSION)); BrokerConfig brokerConfig = new BrokerConfig(); brokerConfig.setNamesrvAddr(nameServer); brokerConfig.setBrokerId(MixAll.MASTER_ID); NettyServerConfig nettyServerConfig = new NettyServerConfig(); nettyServerConfig.setListenPort(10911); NettyClientConfig nettyClientConfig = new NettyClientConfig(); MessageStoreConfig messageStoreConfig = new MessageStoreConfig(); brokerController = new BrokerController(brokerConfig, nettyServerConfig, nettyClientConfig, messageStoreConfig); boolean initResult = brokerController.initialize(); if (!initResult) { brokerController.shutdown(); throw new Exception(); } brokerController.start(); } @Test public void testEvent() throws MQClientException, InterruptedException, EventDeliveryException, RemotingException, MQBrokerException, UnsupportedEncodingException { /* start sink */ Context context = new Context(); context.put(NAME_SERVER_CONFIG, nameServer); context.put(TAG_CONFIG, tag); RocketMQSink sink = new RocketMQSink(); Configurables.configure(sink, context); MemoryChannel channel = new MemoryChannel(); Configurables.configure(channel, context); sink.setChannel(channel); sink.start(); /* mock flume source */ String sendMsg = "\"Hello RocketMQ\"" + "," + DateFormatUtils.format(new Date(), "yyyy-MM-DD hh:mm:ss"); Transaction tx = channel.getTransaction(); tx.begin(); Event event = EventBuilder.withBody(sendMsg.getBytes(), null); channel.put(event); tx.commit(); tx.close(); log.info("publish message : {}", sendMsg); Sink.Status status = sink.process(); if (status == Sink.Status.BACKOFF) { fail("Error"); } sink.stop(); /* consumer message */ consumer = new DefaultMQPullConsumer(consumerGroup); consumer.setNamesrvAddr(nameServer); consumer.setMessageModel(MessageModel.valueOf("BROADCASTING")); consumer.registerMessageQueueListener(TOPIC_DEFAULT, null); consumer.start(); String receiveMsg = null; Set queues = consumer.fetchSubscribeMessageQueues(TOPIC_DEFAULT); for (MessageQueue queue : queues) { long offset = getMessageQueueOffset(queue); PullResult pullResult = consumer.pull(queue, tag, offset, 32); if (pullResult.getPullStatus() == PullStatus.FOUND) { for (MessageExt message : pullResult.getMsgFoundList()) { byte[] body = message.getBody(); receiveMsg = new String(body, "UTF-8"); log.info("receive message : {}", receiveMsg); } long nextBeginOffset = pullResult.getNextBeginOffset(); putMessageQueueOffset(queue, nextBeginOffset); } } /* wait for processQueueTable init */ Thread.sleep(1000); consumer.shutdown(); assertEquals(sendMsg, receiveMsg); } @Test public void testBatchEvent() throws MQClientException, InterruptedException, EventDeliveryException, RemotingException, MQBrokerException, UnsupportedEncodingException { /* start sink */ Context context = new Context(); context.put(NAME_SERVER_CONFIG, nameServer); context.put(TAG_CONFIG, tag); context.put(BATCH_SIZE_CONFIG, String.valueOf(batchSize)); RocketMQSink sink = new RocketMQSink(); Configurables.configure(sink, context); MemoryChannel channel = new MemoryChannel(); Configurables.configure(channel, context); sink.setChannel(channel); sink.start(); /* mock flume source */ Map msgs = new HashMap<>(); Transaction tx = channel.getTransaction(); tx.begin(); int sendNum = 0; for (int i = 0; i < batchSize; i++) { String sendMsg = "\"Hello RocketMQ\"" + "," + DateFormatUtils.format(new Date(), "yyyy-MM-DD hh:mm:ss:SSSS"); Event event = EventBuilder.withBody(sendMsg.getBytes(), null); channel.put(event); log.info("publish message : {}", sendMsg); String[] sendMsgKv = sendMsg.split(","); msgs.put(sendMsgKv[1], sendMsgKv[0]); sendNum++; Thread.sleep(10); } log.info("send message num={}", sendNum); tx.commit(); tx.close(); Sink.Status status = sink.process(); if (status == Sink.Status.BACKOFF) { fail("Error"); } sink.stop(); /* consumer message */ consumer = new DefaultMQPullConsumer(consumerGroup); consumer.setNamesrvAddr(nameServer); consumer.setMessageModel(MessageModel.valueOf("BROADCASTING")); consumer.registerMessageQueueListener(TOPIC_DEFAULT, null); consumer.start(); int receiveNum = 0; String receiveMsg = null; Set queues = consumer.fetchSubscribeMessageQueues(TOPIC_DEFAULT); for (MessageQueue queue : queues) { long offset = getMessageQueueOffset(queue); PullResult pullResult = consumer.pull(queue, tag, offset, batchSize); if (pullResult.getPullStatus() == PullStatus.FOUND) { for (MessageExt message : pullResult.getMsgFoundList()) { byte[] body = message.getBody(); receiveMsg = new String(body, "UTF-8"); String[] receiveMsgKv = receiveMsg.split(","); msgs.remove(receiveMsgKv[1]); log.info("receive message : {}", receiveMsg); receiveNum++; } long nextBeginOffset = pullResult.getNextBeginOffset(); putMessageQueueOffset(queue, nextBeginOffset); } } log.info("receive message num={}", receiveNum); /* wait for processQueueTable init */ Thread.sleep(1000); consumer.shutdown(); assertEquals(msgs.size(), 0); } @Test public void testNullEvent() throws MQClientException, InterruptedException, EventDeliveryException, RemotingException, MQBrokerException, UnsupportedEncodingException { /* start sink */ Context context = new Context(); context.put(NAME_SERVER_CONFIG, nameServer); context.put(TAG_CONFIG, tag); RocketMQSink sink = new RocketMQSink(); Configurables.configure(sink, context); MemoryChannel channel = new MemoryChannel(); Configurables.configure(channel, context); sink.setChannel(channel); sink.start(); Sink.Status status = sink.process(); assertEquals(status, Sink.Status.BACKOFF); sink.stop(); } private long getMessageQueueOffset(MessageQueue queue) throws MQClientException { long offset = consumer.fetchConsumeOffset(queue, false); if (offset < 0) { offset = 0; } return offset; } private void putMessageQueueOffset(MessageQueue queue, long offset) throws MQClientException { consumer.updateConsumeOffset(queue, offset); } @AfterClass public static void stop() { if (brokerController != null) { brokerController.shutdown(); } if (namesrvController != null) { namesrvController.shutdown(); } } } ================================================ FILE: rocketmq-flume/rocketmq-flume-sink/src/test/resources/log4j.properties ================================================ # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # log4j.rootLogger = DEBUG, out log4j.appender.out = org.apache.log4j.ConsoleAppender log4j.appender.out.layout = org.apache.log4j.PatternLayout log4j.appender.out.layout.ConversionPattern = %d (%t) [%p - %l] %m%n log4j.logger.org.apache.rocketmq = DEBUG ================================================ FILE: rocketmq-flume/rocketmq-flume-source/pom.xml ================================================ 4.0.0 org.apache rocketmq-flume 0.0.2-SNAPSHOT rocketmq-flume-source ================================================ FILE: rocketmq-flume/rocketmq-flume-source/src/main/java/org/apache/rocketmq/flume/ng/source/RocketMQSource.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.flume.ng.source; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.flume.Context; import org.apache.flume.Event; import org.apache.flume.FlumeException; import org.apache.flume.conf.Configurable; import org.apache.flume.conf.ConfigurationException; import org.apache.flume.event.EventBuilder; import org.apache.flume.instrumentation.SourceCounter; import org.apache.flume.source.AbstractPollableSource; import org.apache.rocketmq.client.consumer.DefaultLitePullConsumer; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.common.message.MessageExt; import org.apache.rocketmq.common.message.MessageQueue; import org.apache.rocketmq.common.protocol.heartbeat.MessageModel; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.BATCH_SIZE_CONFIG; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.BATCH_SIZE_DEFAULT; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.CONSUMER_GROUP_CONFIG; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.CONSUMER_GROUP_DEFAULT; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.HEADER_TAG_NAME; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.HEADER_TOPIC_NAME; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.MESSAGE_MODEL_CONFIG; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.MESSAGE_MODEL_DEFAULT; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.NAME_SERVER_CONFIG; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.TAG_CONFIG; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.TAG_DEFAULT; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.TOPIC_CONFIG; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.TOPIC_DEFAULT; /** * */ public class RocketMQSource extends AbstractPollableSource implements Configurable { private static final Logger log = LoggerFactory.getLogger(RocketMQSource.class); private String nameServer; private String topic; private String tag; private String consumerGroup; private String messageModel; private Integer batchSize; /** Monitoring counter. */ private SourceCounter sourceCounter; DefaultLitePullConsumer consumer; @Override protected void doConfigure(Context context) throws FlumeException { nameServer = context.getString(NAME_SERVER_CONFIG); if (nameServer == null) { throw new ConfigurationException("NameServer must not be null"); } topic = context.getString(TOPIC_CONFIG, TOPIC_DEFAULT); tag = context.getString(TAG_CONFIG, TAG_DEFAULT); consumerGroup = context.getString(CONSUMER_GROUP_CONFIG, CONSUMER_GROUP_DEFAULT); messageModel = context.getString(MESSAGE_MODEL_CONFIG, MESSAGE_MODEL_DEFAULT); batchSize = context.getInteger(BATCH_SIZE_CONFIG, BATCH_SIZE_DEFAULT); if (sourceCounter == null) { sourceCounter = new SourceCounter(getName()); } } @Override protected void doStart() throws FlumeException { consumer = new DefaultLitePullConsumer(consumerGroup); consumer.setNamesrvAddr(nameServer); consumer.setMessageModel(MessageModel.valueOf(messageModel)); consumer.setPullBatchSize(batchSize); try { consumer.subscribe(topic, tag); consumer.start(); } catch (MQClientException e) { log.error("RocketMQ consumer start failed", e); throw new FlumeException("Failed to start RocketMQ consumer", e); } sourceCounter.start(); } @Override protected Status doProcess() { List events = new ArrayList<>(); Map offsets = new HashMap<>(); Event event; Map headers; try { List messageExts = consumer.poll(); for (MessageExt msg : messageExts) { byte[] body = msg.getBody(); headers = new HashMap<>(); headers.put(HEADER_TOPIC_NAME, topic); headers.put(HEADER_TAG_NAME, tag); log.debug("Processing message,body={}", new String(body, "UTF-8")); event = EventBuilder.withBody(body, headers); events.add(event); } if (events.size() > 0) { sourceCounter.incrementAppendBatchReceivedCount(); sourceCounter.addToEventReceivedCount(events.size()); getChannelProcessor().processEventBatch(events); sourceCounter.incrementAppendBatchAcceptedCount(); sourceCounter.addToEventAcceptedCount(events.size()); events.clear(); } } catch (Exception e) { log.error("Failed to consumer message", e); return Status.BACKOFF; } return Status.READY; } @Override protected void doStop() throws FlumeException { sourceCounter.stop(); consumer.shutdown(); } } ================================================ FILE: rocketmq-flume/rocketmq-flume-source/src/main/java/org/apache/rocketmq/flume/ng/source/RocketMQSourceConstants.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.flume.ng.source; /** * */ public class RocketMQSourceConstants { public static final String NAME_SERVER_CONFIG = "nameserver"; public static final String TOPIC_CONFIG = "topic"; public static final String TOPIC_DEFAULT = "FLUME_TOPIC"; public static final String TAG_CONFIG = "tag"; public static final String TAG_DEFAULT = "FLUME_TAG"; public static final String CONSUMER_GROUP_CONFIG = "consumerGroup"; public static final String CONSUMER_GROUP_DEFAULT = "FLUME_CONSUMER_GROUP"; public static final String MESSAGE_MODEL_CONFIG = "messageModel"; public static final String MESSAGE_MODEL_DEFAULT = "BROADCASTING"; public static final String BATCH_SIZE_CONFIG = "batchSize"; public static final int BATCH_SIZE_DEFAULT = 32; public static final String HEADER_TOPIC_NAME = "topic"; public static final String HEADER_TAG_NAME = "tag"; } ================================================ FILE: rocketmq-flume/rocketmq-flume-source/src/test/java/org/apache/rocketmq/flume/ng/source/RocketMQSourceTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.flume.ng.source; import java.io.UnsupportedEncodingException; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Random; import org.apache.commons.lang.time.DateFormatUtils; import org.apache.flume.Channel; import org.apache.flume.ChannelSelector; import org.apache.flume.Context; import org.apache.flume.Event; import org.apache.flume.EventDeliveryException; import org.apache.flume.PollableSource; import org.apache.flume.Transaction; import org.apache.flume.channel.ChannelProcessor; import org.apache.flume.channel.MemoryChannel; import org.apache.flume.channel.ReplicatingChannelSelector; import org.apache.flume.conf.Configurables; import org.apache.rocketmq.broker.BrokerController; import org.apache.rocketmq.client.exception.MQBrokerException; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.client.producer.DefaultMQProducer; import org.apache.rocketmq.client.producer.SendResult; import org.apache.rocketmq.common.BrokerConfig; import org.apache.rocketmq.common.MQVersion; import org.apache.rocketmq.common.MixAll; import org.apache.rocketmq.common.message.Message; import org.apache.rocketmq.common.namesrv.NamesrvConfig; import org.apache.rocketmq.namesrv.NamesrvController; import org.apache.rocketmq.remoting.exception.RemotingException; import org.apache.rocketmq.remoting.netty.NettyClientConfig; import org.apache.rocketmq.remoting.netty.NettyServerConfig; import org.apache.rocketmq.remoting.protocol.RemotingCommand; import org.apache.rocketmq.store.config.MessageStoreConfig; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.NAME_SERVER_CONFIG; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.TAG_CONFIG; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.TAG_DEFAULT; import static org.apache.rocketmq.flume.ng.source.RocketMQSourceConstants.TOPIC_DEFAULT; import static org.junit.Assert.assertEquals; import static org.junit.Assert.fail; /** * */ public class RocketMQSourceTest { private static final Logger log = LoggerFactory.getLogger(RocketMQSourceTest.class); private static String nameServer = "localhost:9876"; private static NamesrvController namesrvController; private static BrokerController brokerController; private String tag = TAG_DEFAULT + "_SOURCE_TEST_" + new Random().nextInt(99); private String producerGroup = "PRODUCER_GROUP_SOURCE_TEST"; @BeforeClass public static void startMQ() throws Exception { /* start nameserver */ startNamesrv(); /* start broker */ startBroker(); Thread.sleep(2000); } private static void startNamesrv() throws Exception { NamesrvConfig namesrvConfig = new NamesrvConfig(); NettyServerConfig nettyServerConfig = new NettyServerConfig(); nettyServerConfig.setListenPort(9876); namesrvController = new NamesrvController(namesrvConfig, nettyServerConfig); boolean initResult = namesrvController.initialize(); if (!initResult) { namesrvController.shutdown(); throw new Exception(); } namesrvController.start(); } private static void startBroker() throws Exception { System.setProperty(RemotingCommand.REMOTING_VERSION_KEY, Integer.toString(MQVersion.CURRENT_VERSION)); BrokerConfig brokerConfig = new BrokerConfig(); brokerConfig.setNamesrvAddr(nameServer); brokerConfig.setBrokerId(MixAll.MASTER_ID); NettyServerConfig nettyServerConfig = new NettyServerConfig(); nettyServerConfig.setListenPort(10911); NettyClientConfig nettyClientConfig = new NettyClientConfig(); MessageStoreConfig messageStoreConfig = new MessageStoreConfig(); brokerController = new BrokerController(brokerConfig, nettyServerConfig, nettyClientConfig, messageStoreConfig); boolean initResult = brokerController.initialize(); if (!initResult) { brokerController.shutdown(); throw new Exception(); } brokerController.start(); } @Test public void testEvent() throws EventDeliveryException, MQBrokerException, MQClientException, InterruptedException, UnsupportedEncodingException, RemotingException { // publish message before flume-source start DefaultMQProducer producer = new DefaultMQProducer(producerGroup); producer.setNamesrvAddr(nameServer); String sendMsg = "\"Hello Flume\"" + "," + DateFormatUtils.format(new Date(), "yyyy-MM-dd hh:mm:ss"); producer.start(); Message msg = new Message(TOPIC_DEFAULT, tag, sendMsg.getBytes("UTF-8")); SendResult sendResult = producer.send(msg); // start source Context context = new Context(); context.put(NAME_SERVER_CONFIG, nameServer); context.put(TAG_CONFIG, tag); Channel channel = new MemoryChannel(); Configurables.configure(channel, context); List channels = new ArrayList<>(); channels.add(channel); ChannelSelector channelSelector = new ReplicatingChannelSelector(); channelSelector.setChannels(channels); ChannelProcessor channelProcessor = new ChannelProcessor(channelSelector); RocketMQSource source = new RocketMQSource(); source.setChannelProcessor(channelProcessor); Configurables.configure(source, context); source.start(); // wait for rebalanceImpl start Thread.sleep(2000); sendMsg = "\"Hello Flume\"" + "," + DateFormatUtils.format(new Date(), "yyyy-MM-dd hh:mm:ss"); msg = new Message(TOPIC_DEFAULT, tag, sendMsg.getBytes("UTF-8")); sendResult = producer.send(msg); log.info("publish message : {}, sendResult:{}", sendMsg, sendResult); PollableSource.Status status = source.process(); if (status == PollableSource.Status.BACKOFF) { fail("Error"); } /* wait for processQueueTable init */ Thread.sleep(1000); producer.shutdown(); source.stop(); /* mock flume sink */ Transaction transaction = channel.getTransaction(); transaction.begin(); Event event = channel.take(); if (event == null) { transaction.commit(); fail("Error"); } byte[] body = event.getBody(); String receiveMsg = new String(body, "UTF-8"); log.info("receive message : {}", receiveMsg); assertEquals(sendMsg, receiveMsg); } @AfterClass public static void stop() { if (brokerController != null) { brokerController.shutdown(); } if (namesrvController != null) { namesrvController.shutdown(); } } } ================================================ FILE: rocketmq-flume/rocketmq-flume-source/src/test/resources/log4j.properties ================================================ # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # log4j.rootLogger = DEBUG, out log4j.appender.out = org.apache.log4j.ConsoleAppender log4j.appender.out.layout = org.apache.log4j.PatternLayout log4j.appender.out.layout.ConversionPattern = %d (%t) [%p - %l] %m%n log4j.logger.org.apache.rocketmq = DEBUG ================================================ FILE: rocketmq-flume/style/copyright/Apache.xml ================================================ ================================================ FILE: rocketmq-flume/style/copyright/profiles_settings.xml ================================================ ================================================ FILE: rocketmq-flume/style/rmq_checkstyle.xml ================================================ ================================================ FILE: rocketmq-flume/style/rmq_codeStyle.xml ================================================ ================================================ FILE: rocketmq-hbase/README.md ================================================ # RocketMQ-HBase ## Overview This project provides connectors between RocketMQ and HBase. The [HBase sink](rocketmq-hbase-sink) replicates HBase tables to RocketMQ topics, and the [HBase source](rocketmq-hbase-source) replicates RocketMQ topics to HBase tables. ================================================ FILE: rocketmq-hbase/pom.xml ================================================ 4.0.0 org.apache rocketmq-hbase pom 1.0-SNAPSHOT rocketmq-hbase-sink rocketmq-hbase-source UTF-8 UTF-8 false true 1.8 1.8 4.2.0 1.4.4 org.apache.rocketmq rocketmq-client ${rocketmq.version} org.slf4j slf4j-api 1.7.5 org.apache.hbase hbase-server ${hbase.version} org.apache.hbase hbase-testing-util ${hbase.version} test org.apache.rocketmq rocketmq-namesrv ${rocketmq.version} test ch.qos.logback logback-classic org.apache.rocketmq rocketmq-broker ${rocketmq.version} test ch.qos.logback logback-classic io.netty netty-tcnative org.apache.maven.plugins maven-shade-plugin 3.1.1 package shade maven-checkstyle-plugin 2.17 verify verify style/rmq_checkstyle.xml UTF-8 true true false false check ================================================ FILE: rocketmq-hbase/rocketmq-hbase-sink/README.md ================================================ # RocketMQ-HBase Sink ## Overview This project replicates HBase tables to RocketMQ topics. ## Pre-requisites - HBase 1.2+ - JDK 1.8+ - RocketMQ 4.0.0+ ## Requirements - HBase cluster is configured with the setting `hbase.replication` to `true` in hbase-site.xml ## Properties Have the below properties set in `hbase-site.xml` and add it to the HBase region server classpath. |key |nullable|default |description| |------------------|--------|-----------|-----------| |rocketmq.namesrv.addr |false | |RocketMQ name server address (e.g.,127.0.0.1:9876)| |rocketmq.topic | false | | RocketMQ topic to replicate HBase data to. | |rocketmq.hbase.tables |false | | List of HBase tables, separated by comma, to replicate to RocketMQ (e.g., table1,table2,table3)| ## Deployment 1. Add rocketmq-hbase-X.Y-SNAPSHOT.jar and hbase-site.xml with the required properties to all the HBase region servers classpath and restart them. 2. At HBase shell, run the following commands. ```bash hbase> create 'test', {NAME => 'd', REPLICATION_SCOPE => '1'} hbase> add_peer 'rocketmq-repl', ENDPOINT_CLASSNAME => 'org.apache.rocketmq.hbase.Replicator' hbase> put 'test', 'r1', 'd', 'value' ``` ================================================ FILE: rocketmq-hbase/rocketmq-hbase-sink/pom.xml ================================================ rocketmq-hbase org.apache 1.0-SNAPSHOT 4.0.0 rocketmq-hbase-sink ================================================ FILE: rocketmq-hbase/rocketmq-hbase-sink/src/main/java/org/apache/rocketmq/hbase/sink/DataRow.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.hbase.sink; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellUtil; import org.apache.hadoop.hbase.util.Bytes; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.HashMap; import java.util.List; import java.util.Map; import static java.util.stream.Collectors.groupingBy; /** * This class represents a HBase data row. */ public class DataRow { private static final Logger logger = LoggerFactory.getLogger(DataRow.class); private String type; private String table; private byte[] row; private List cells; /** * Constructor. * * @param type the type of operation, put or delete * @param table the table * @param row the row key * @param cells the cells */ public DataRow(String type, String table, byte[] row, List cells) { this.type = type; this.table = table; this.row = row; this.cells = cells; } /** * Converts this data row to a map. * * @return a map structure containing a representation of this row */ public Map toMap() { final Map dataMap = new HashMap<>(); final Map> columnsByFamily = cells.stream().collect(groupingBy(CellUtil::cloneFamily)); for(Map.Entry> entry : columnsByFamily.entrySet()) { final String columnFamily = Bytes.toString(entry.getKey()); final List cells = entry.getValue(); final Map qualifiers = new HashMap<>(); for (Cell cell : cells) { if (cell.getQualifierLength() > 0) { final String columnQualifier = Bytes.toString(CellUtil.cloneQualifier(cell)); qualifiers.put(columnQualifier, CellUtil.cloneValue(cell)); } else { dataMap.put(columnFamily, CellUtil.cloneValue(cell)); } } if (qualifiers.size() > 0) { dataMap.put(columnFamily, qualifiers); } } Map map = new HashMap<>(); map.put("table", table); map.put("type", type); map.put("row", Bytes.toString(row)); map.put("data", dataMap); return map; } } ================================================ FILE: rocketmq-hbase/rocketmq-hbase-sink/src/main/java/org/apache/rocketmq/hbase/sink/Replicator.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.hbase.sink; import com.google.common.collect.Sets; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellUtil; import org.apache.hadoop.hbase.replication.BaseReplicationEndpoint; import org.apache.hadoop.hbase.wal.WAL; import org.apache.rocketmq.client.exception.MQClientException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.UUID; import static java.util.stream.Collectors.groupingBy; /** * This class functions as an HBase replication endpoint, that runs at each region server, * and replicates data from specified HBase tables to a RocketMQ topic. */ public class Replicator extends BaseReplicationEndpoint { private static final String ROCKETMQ_NAMESRV_ADDR_PARAM = "rocketmq.namesrv.addr"; private static final String ROCKETMQ_TOPIC_PARAM = "rocketmq.topic"; private static final String ROCKETMQ_HBASE_TABLES_PARAM = "rocketmq.hbase.tables"; private static final String ROCKETMQ_TRANSACTION_ROWS_PARAM = "rocketmq.transaction.max.rows"; private static final int ROCKETMQ_TRANSACTION_ROWS_DEFAULT = 100; private static final Logger logger = LoggerFactory.getLogger(Replicator.class); private RocketMQProducer producer; private Set tables = Sets.newHashSet(); private int maxTransactionRows; /** * Constructor. */ public Replicator() { super(); } /** * {@inheritDoc} */ @Override public void init(Context context) throws IOException { super.init(context); logger.info("HBaseEndpoint initialized"); } /** * {@inheritDoc} */ @Override protected void doStart() { final Configuration config = ctx.getConfiguration(); final String namesrvAddr = config.get(ROCKETMQ_NAMESRV_ADDR_PARAM); if (namesrvAddr == null) { logger.error("Configuration property not set: " + ROCKETMQ_NAMESRV_ADDR_PARAM); return; } final String topic = config.get(ROCKETMQ_TOPIC_PARAM); if (topic == null) { logger.error("Configuration property not set: " + ROCKETMQ_TOPIC_PARAM); return; } final String tablesParam = config.get(ROCKETMQ_HBASE_TABLES_PARAM); if (tablesParam == null) { logger.error("Configuration property not set: " + ROCKETMQ_HBASE_TABLES_PARAM); return; } tables = new HashSet<>(Arrays.asList(tablesParam.split(","))); maxTransactionRows = config.getInt(ROCKETMQ_TRANSACTION_ROWS_PARAM, ROCKETMQ_TRANSACTION_ROWS_DEFAULT); try { producer = new RocketMQProducer(namesrvAddr, topic); producer.start(); logger.info("HBase replication to RocketMQ started"); notifyStarted(); } catch (MQClientException e) { logger.error("Failed to start RocketMQ producer.", e); } } /** * {@inheritDoc} */ @Override protected void doStop() { producer.stop(); logger.info("HBase replication to RocketMQ stopped."); notifyStopped(); } /** * {@inheritDoc} */ @Override public UUID getPeerUUID() { return UUID.randomUUID(); } /** * {@inheritDoc} */ @Override public boolean replicate(ReplicateContext context) { final List entries = context.getEntries(); final Map> entriesByTable = entries.stream() .filter(entry -> tables.contains(entry.getKey().getTablename().getNameAsString())) .collect(groupingBy(entry -> entry.getKey().getTablename().getNameAsString())); // replicate data to rocketmq Transaction transaction = new Transaction(maxTransactionRows); try { for (Map.Entry> entry : entriesByTable.entrySet()) { final String tableName = entry.getKey(); final List tableEntries = entry.getValue(); for (WAL.Entry tableEntry : tableEntries) { List cells = tableEntry.getEdit().getCells(); // group entries by the row key Map> columnsByRow = cells.stream().collect(groupingBy(CellUtil::cloneRow)); for (Map.Entry> rowCols : columnsByRow.entrySet()) { final byte[] row = rowCols.getKey(); final List columns = rowCols.getValue(); if (!transaction.addRow(tableName, row, columns)) { producer.push(transaction.toJson()); transaction = new Transaction(maxTransactionRows); } } } } // replicate remaining transaction producer.push(transaction.toJson()); } catch (Exception e) { logger.error("Error while sending message to RocketMQ.", e); return false; } return true; } } ================================================ FILE: rocketmq-hbase/rocketmq-hbase-sink/src/main/java/org/apache/rocketmq/hbase/sink/RocketMQProducer.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.hbase.sink; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.client.producer.DefaultMQProducer; import org.apache.rocketmq.client.producer.SendResult; import org.apache.rocketmq.common.message.Message; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * This class represents the RocketMQ producer that effectively pushes the messages to the RocketMQ server. */ public class RocketMQProducer { private static final String PRODUCER_GROUP_NAME = "HBASE_PRODUCER_GROUP"; private static final Logger logger = LoggerFactory.getLogger(RocketMQProducer.class); private DefaultMQProducer producer; private String namesrvAddr; private String topic; /** * Constructor. * * @param namesrvAddr the nameserver address * @param topic the topic to write to */ public RocketMQProducer(String namesrvAddr, String topic) { this.namesrvAddr = namesrvAddr; this.topic = topic; } /** * Starts the producer. * * @throws MQClientException */ public void start() throws MQClientException { producer = new DefaultMQProducer(PRODUCER_GROUP_NAME); producer.setInstanceName("producer-" + System.currentTimeMillis()); producer.setNamesrvAddr(namesrvAddr); producer.start(); } /** * Pushes messages to the RocketMQ server. * * @param json the message to be sent in json format * @return the result status code * @throws Exception */ public long push(String json) throws Exception { logger.debug(json); Message message = new Message(topic, json.getBytes("UTF-8")); SendResult sendResult = producer.send(message); return sendResult.getQueueOffset(); } /** * Stops the RocketMQ producer. */ public void stop() { producer.shutdown(); } } ================================================ FILE: rocketmq-hbase/rocketmq-hbase-sink/src/main/java/org/apache/rocketmq/hbase/sink/Transaction.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.hbase.sink; import com.alibaba.fastjson.JSONObject; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.stream.Collectors; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.protobuf.generated.CellProtos; /** * This class represents a transaction that contains a fixed amount of HBase rows that are to be pushed together to * RocketMQ. */ public class Transaction { private final int maxTransactionRows; private List rows = new LinkedList<>(); /** * Constructor. * * @param maxTransactionRows number of maximum rows supported by this transaction */ public Transaction(int maxTransactionRows) { this.maxTransactionRows = maxTransactionRows; } /** * Adds a row to this transaction. * * @param tableName the name of the HBase table * @param rowKey the row key * @param cells the cells * @return true if more rows can be added to this transaction; false otherwise. */ public boolean addRow(String tableName, byte[] rowKey, List cells) { final Cell cell = cells.get(0); final CellProtos.CellType type = CellProtos.CellType.valueOf(cell.getTypeByte()); final String typeStr; switch (type) { case DELETE: typeStr = "DELETE"; break; case DELETE_COLUMN: typeStr = "DELETE_COLUMN"; break; case DELETE_FAMILY: typeStr = "DELETE_FAMILY"; break; case PUT: typeStr = "PUT"; break; default: typeStr = null; } DataRow dataRow = new DataRow(typeStr, tableName, rowKey, cells); rows.add(dataRow); return rows.size() < maxTransactionRows; } // private void toRowColumns(final List cells) { // //// cells.stream().map(cell -> { //// byte[] family = CellUtil.cloneFamily(cell); //// byte[] qualifier = CellUtil.cloneQualifier(cell); //// byte[] value = CellUtil.cloneValue(cell); //// long timestamp = cell.getTimestamp(); //// //// final HRow.HColumn column = new HRow.HColumn(family, qualifier, value, timestamp); //// return column; //// }).collect(toList()); //// //// return columns; // } /** * Converts this transaction to json. * * @return a string with the json representation of this transaction */ public String toJson() { Map map = new HashMap<>(); List> rowsMap = rows.stream().map(row -> row.toMap()).collect(Collectors.toList()); map.put("rows", rowsMap); return JSONObject.toJSONString(map); } } ================================================ FILE: rocketmq-hbase/rocketmq-hbase-sink/src/test/java/org/apache/rocketmq/sink/ReplicatorTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.sink; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.HBaseTestingUtility; import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.ConnectionFactory; import org.apache.hadoop.hbase.client.HBaseAdmin; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.client.replication.ReplicationAdmin; import org.apache.hadoop.hbase.replication.ReplicationException; import org.apache.hadoop.hbase.replication.ReplicationPeerConfig; import org.apache.hadoop.hbase.zookeeper.ZKConfig; import org.apache.rocketmq.broker.BrokerController; import org.apache.rocketmq.client.consumer.DefaultMQPullConsumer; import org.apache.rocketmq.client.consumer.PullResult; import org.apache.rocketmq.client.consumer.PullStatus; import org.apache.rocketmq.client.exception.MQBrokerException; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.common.BrokerConfig; import org.apache.rocketmq.common.MQVersion; import org.apache.rocketmq.common.MixAll; import org.apache.rocketmq.common.message.MessageExt; import org.apache.rocketmq.common.message.MessageQueue; import org.apache.rocketmq.common.namesrv.NamesrvConfig; import org.apache.rocketmq.common.protocol.heartbeat.MessageModel; import org.apache.rocketmq.hbase.sink.Replicator; import org.apache.rocketmq.hbase.sink.Transaction; import org.apache.rocketmq.namesrv.NamesrvController; import org.apache.rocketmq.remoting.exception.RemotingException; import org.apache.rocketmq.remoting.netty.NettyClientConfig; import org.apache.rocketmq.remoting.netty.NettyServerConfig; import org.apache.rocketmq.remoting.protocol.RemotingCommand; import org.apache.rocketmq.store.config.MessageStoreConfig; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; import static org.apache.hadoop.hbase.util.Bytes.toBytes; import static org.junit.Assert.assertEquals; /** * This class tests the replicator by writing data from hbase to rocketmq and reading it back. */ public class ReplicatorTest { private static final String CONSUMER_GROUP_NAME = "HBASE_CONSUMER_GROUP_TEST"; private static final String ROCKETMQ_TOPIC = "rocketmq-hbase-topic-test"; private static final String NAMESERVER = "localhost:9876"; private static final String TABLE_NAME_STR = "hbase-rocketmq-test"; private static final String PEER_NAME = "rocketmq.hbase"; private final TableName TABLE_NAME = TableName.valueOf(TABLE_NAME_STR); private final String ROWKEY = "rk-%s"; private final String COLUMN_FAMILY = "d"; private final String QUALIFIER = "q"; private final String VALUE = "v"; private static final Logger logger = LoggerFactory.getLogger(ReplicatorTest.class); private static NamesrvController namesrvController; private static BrokerController brokerController; private HBaseTestingUtility utility; private int numRegionServers; private int batchSize = 100; /** * This method starts the HBase cluster and the RocketMQ server. * * @throws Exception */ @Before public void setUp() throws Exception { final Configuration hbaseConf = HBaseConfiguration.create(); hbaseConf.setInt("replication.stats.thread.period.seconds", 5); hbaseConf.setLong("replication.sleep.before.failover", 2000); hbaseConf.setInt("replication.source.maxretriesmultiplier", 10); hbaseConf.setBoolean(HConstants.REPLICATION_ENABLE_KEY, true); // Add RocketMQ properties - we prefix each property with 'rocketmq' addRocketMQProperties(hbaseConf); utility = new HBaseTestingUtility(hbaseConf); utility.startMiniCluster(); utility.getHBaseCluster().getRegionServerThreads().size(); // setup and start RocketMQ startMQ(); } /** * Add RocketMQ properties to {@link Configuration} * * @param hbaseConf */ private void addRocketMQProperties(Configuration hbaseConf) { hbaseConf.set("rocketmq.namesrv.addr", NAMESERVER); hbaseConf.set("rocketmq.topic", ROCKETMQ_TOPIC); hbaseConf.set("rocketmq.hbase.tables", TABLE_NAME_STR); } /** * @param configuration * @param peerName * @param tableCFs * @throws ReplicationException * @throws IOException */ private void addPeer(final Configuration configuration, String peerName, Map> tableCFs) throws ReplicationException, IOException { try (ReplicationAdmin replicationAdmin = new ReplicationAdmin(configuration)) { ReplicationPeerConfig peerConfig = new ReplicationPeerConfig() .setClusterKey(ZKConfig.getZooKeeperClusterKey(configuration)) .setReplicationEndpointImpl(Replicator.class.getName()); replicationAdmin.addPeer(peerName, peerConfig, tableCFs); } } /** * This method starts the RocketMQ server. * * @throws Exception */ private static void startMQ() throws Exception { startNamesrv(); startBroker(); Thread.sleep(2000); } /** * This method starts the RocketMQ nameserver. * * @throws Exception */ private static void startNamesrv() throws Exception { final NamesrvConfig namesrvConfig = new NamesrvConfig(); NettyServerConfig nettyServerConfig = new NettyServerConfig(); nettyServerConfig.setListenPort(9876); namesrvController = new NamesrvController(namesrvConfig, nettyServerConfig); final boolean initResult = namesrvController.initialize(); if (!initResult) { namesrvController.shutdown(); throw new Exception("Name server controller failed to initialize."); } namesrvController.start(); } /** * This method starts the RocketMQ broker. * * @throws Exception */ private static void startBroker() throws Exception { System.setProperty(RemotingCommand.REMOTING_VERSION_KEY, Integer.toString(MQVersion.CURRENT_VERSION)); final BrokerConfig brokerConfig = new BrokerConfig(); brokerConfig.setNamesrvAddr(NAMESERVER); brokerConfig.setBrokerId(MixAll.MASTER_ID); final NettyServerConfig nettyServerConfig = new NettyServerConfig(); nettyServerConfig.setListenPort(10911); final NettyClientConfig nettyClientConfig = new NettyClientConfig(); final MessageStoreConfig messageStoreConfig = new MessageStoreConfig(); brokerController = new BrokerController(brokerConfig, nettyServerConfig, nettyClientConfig, messageStoreConfig); boolean initResult = brokerController.initialize(); if (!initResult) { brokerController.shutdown(); throw new Exception(); } brokerController.start(); } /** * This method tests the replicator by writing data from hbase to rocketmq and reading it back. * * @throws IOException * @throws ReplicationException * @throws InterruptedException * @throws MQClientException * @throws RemotingException * @throws MQBrokerException */ @Test public void testCustomReplicationEndpoint() throws IOException, ReplicationException, InterruptedException, MQClientException, RemotingException, MQBrokerException { final DefaultMQPullConsumer consumer = new DefaultMQPullConsumer(CONSUMER_GROUP_NAME); try { createTestTable(); final Map> tableCfs = new HashMap<>(); List cfs = new ArrayList<>(); cfs.add(COLUMN_FAMILY); tableCfs.put(TABLE_NAME, cfs); addPeer(utility.getConfiguration(), PEER_NAME, tableCfs); // wait for new peer to be added Thread.sleep(500); final int numberOfRecords = 10; final Transaction inTransaction = insertData(numberOfRecords); // wait for data to be replicated Thread.sleep(500); consumer.setNamesrvAddr(NAMESERVER); consumer.setMessageModel(MessageModel.valueOf("BROADCASTING")); consumer.registerMessageQueueListener(ROCKETMQ_TOPIC, null); consumer.start(); int receiveNum = 0; String receiveMsg = null; Set queues = consumer.fetchSubscribeMessageQueues(ROCKETMQ_TOPIC); for (MessageQueue queue : queues) { long offset = getMessageQueueOffset(consumer, queue); PullResult pullResult = consumer.pull(queue, null, offset, batchSize); if (pullResult.getPullStatus() == PullStatus.FOUND) { for (MessageExt message : pullResult.getMsgFoundList()) { byte[] body = message.getBody(); receiveMsg = new String(body, "UTF-8"); // String[] receiveMsgKv = receiveMsg.split(","); // msgs.remove(receiveMsgKv[1]); logger.info("receive message : {}", receiveMsg); receiveNum++; } long nextBeginOffset = pullResult.getNextBeginOffset(); consumer.updateConsumeOffset(queue, offset); } } logger.info("receive message num={}", receiveNum); // wait for processQueueTable init Thread.sleep(1000); assertEquals(inTransaction.toJson(), receiveMsg); } finally { removePeer(); consumer.shutdown(); } } /** * Gets the message queue offset. * * @param consumer the rocketmq consumer * @param queue the queue from where to consume the message * @return the offset * @throws MQClientException */ private long getMessageQueueOffset(DefaultMQPullConsumer consumer, MessageQueue queue) throws MQClientException { long offset = consumer.fetchConsumeOffset(queue, false); if (offset < 0) { offset = 0; } return offset; } /** * Creates the HBase table with a scope set to global. * * @throws IOException */ private void createTestTable() throws IOException { try (HBaseAdmin hBaseAdmin = utility.getHBaseAdmin()) { final HTableDescriptor hTableDescriptor = new HTableDescriptor(TABLE_NAME); final HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(COLUMN_FAMILY); hColumnDescriptor.setScope(HConstants.REPLICATION_SCOPE_GLOBAL); hTableDescriptor.addFamily(hColumnDescriptor); hBaseAdmin.createTable(hTableDescriptor); } utility.waitUntilAllRegionsAssigned(TABLE_NAME); } /** * Adds data to the previously created HBase table. * * @throws IOException */ private Transaction insertData(int numberOfRecords) throws IOException { final Transaction transaction = new Transaction(numberOfRecords); try (Table hTable = ConnectionFactory.createConnection(utility.getConfiguration()).getTable(TABLE_NAME)) { for (int i = 0; i < numberOfRecords; i++) { final byte[] rowKey = toBytes(String.format(ROWKEY, i)); final byte[] family = toBytes(COLUMN_FAMILY); final Put put = new Put(rowKey); put.addColumn(family, toBytes(QUALIFIER), toBytes(VALUE)); hTable.put(put); List cells = put.getFamilyCellMap().get(family); transaction.addRow(TABLE_NAME_STR, rowKey, cells); } } return transaction; } /** * Removes the HBase peer. * * @throws IOException * @throws ReplicationException */ private void removePeer() throws IOException, ReplicationException { try (ReplicationAdmin replicationAdmin = new ReplicationAdmin(utility.getConfiguration())) { replicationAdmin.removePeer(PEER_NAME); } } /** * Shuts down the HBase cluster and the RocketMQ server. * * @throws Exception */ @After public void tearDown() throws Exception { if (utility != null) { utility.shutdownMiniCluster(); } if (brokerController != null) { brokerController.shutdown(); } if (namesrvController != null) { namesrvController.shutdown(); } } } ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/LICENSE-BIN ================================================ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright {} 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. ------ This product has a bundle logback, which is available under the EPL v1.0 License. The source code of logback can be found at https://github.com/qos-ch/logback. Logback LICENSE --------------- Logback: the reliable, generic, fast and flexible logging framework. Copyright (C) 1999-2015, QOS.ch. All rights reserved. This program and the accompanying materials are dual-licensed under either the terms of the Eclipse Public License v1.0 as published by the Eclipse Foundation or (per the licensee's choosing) under the terms of the GNU Lesser General Public License version 2.1 as published by the Free Software Foundation. ------ This product has a bundle slf4j, which is available under the MIT License. The source code of slf4j can be found at https://github.com/qos-ch/slf4j. Copyright (c) 2004-2017 QOS.ch All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ------ This product has a bundle fastjson, which is available under the ASL2 License. The source code of fastjson can be found at https://github.com/alibaba/fastjson. Copyright 1999-2017 Alibaba Group Holding Ltd. 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. ------ This product has a bundle druid, which is available under the ASL2 License. The source code of druid can be found at https://github.com/alibaba/druid. Copyright 1999-2017 Alibaba Group Holding Ltd. 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. ------ This product has a bundle commons-codec, which is available under the ASL2 License. The source code of commons-codec can be found at http://svn.apache.org/viewvc/commons/proper/codec/trunk/. Apache Commons Codec Copyright 2002-2016 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). src/test/org/apache/commons/codec/language/DoubleMetaphoneTest.java contains test data from http://aspell.net/test/orig/batch0.tab. Copyright (C) 2002 Kevin Atkinson (kevina@gnu.org) ------ This product has a bundle mysql-binlog-connector-java, which is available under the ASL2 License. The source code of mysql-binlog-connector-java can be found at https://github.com/shyiko/mysql-binlog-connector-java. ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/NOTICE-BIN ================================================ Apache RocketMQ (incubating) Copyright 2016-2017 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/README.md ================================================ # RocketMQ-HBase Source ## Overview This project replicates RocketMQ topics to HBase tables. ## Pre-requisites - HBase 1.2+ - JDK 1.8+ - RocketMQ 4.0.0+ ## Assumptions - Each specified RocketMQ topic is mapped to a HBase table with the same name - The HBase tables already exist ## Properties Have the below properties set in `rocketmq_hbase.conf` |key |nullable|default |description| |------------------|--------|-----------|-----------| | topics | false | | A comma separated list of RocketMQ topics to replicate to HBase (e.g., topic1,topic2,topic3) | | nameserver |true | localhost:9876 |RocketMQ name server address | | consumerGroup | true |HBASE_CONSUMER_GROUP| The consumer group name| | messageModel | true | BROADCASTING |RocketMQ message model, 'BROADCASTING' or 'CLUSTERING'| | zookeeperAddress | true | localhost | A comma separated list of the IP addresses of all ZooKeeper servers in the cluster | | zookeeperPort | true | 2181 | The port at which the clients will connect | | batchSize | true | 32 | The maximum number of messages to be consumed in batch from RocketMQ| | pullInterval | true | 1000 | Time in milliseconds to wait between consecutive pulls | ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/pom.xml ================================================ rocketmq-hbase org.apache 1.0-SNAPSHOT 4.0.0 rocketmq-hbase-source maven-jar-plugin 2.4 false true lib/ rocketmq_hbase.conf logback.xml maven-assembly-plugin 3.1.0 src/main/assembly/assembly.xml make-assembly package single ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/src/main/assembly/assembly.xml ================================================ pack tar.gz dir false true lib src/main/assembly/scripts bin 0755 target/classes conf 0755 *.conf logback.xml LICENSE-BIN LICENSE NOTICE-BIN NOTICE ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/src/main/assembly/scripts/start.sh ================================================ #!/usr/bin/env bash binPath=$(cd "$(dirname "$0")"; pwd); cd $binPath cd .. parentPath=`pwd` libPath=$parentPath/lib/ function exportClassPath(){ jarFileList=`find "$libPath" -name *.jar |awk -F'/' '{print $(NF)}' 2>>/dev/null` CLASSPATH=".:$binPath"; for jarItem in $jarFileList do CLASSPATH="$CLASSPATH:$libPath$jarItem" done CLASSPATH=$CLASSPATH:./conf export CLASSPATH } exportClassPath java -server -Xms512m -Xmx512m -Xss2m -XX:NewRatio=2 -XX:+UseGCOverheadLimit -XX:-UseParallelGC -XX:ParallelGCThreads=24 org.apache.rocketmq.hbase.source.RocketMQSource ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/src/main/assembly/scripts/stop.sh ================================================ #!/usr/bin/env bash PROGRAM_NAME="org.apache.rocketmq.hbase.source.RocketMQSource" PIDS=`ps -ef | grep $PROGRAM_NAME | grep -v "grep" | awk '{print $2}'` if [ -z $PIDS ]; then echo "$PROGRAM_NAME is not running." else echo "$PROGRAM_NAME pids are $PIDS." fi #####kill#### echo -e "Stopping the $PROGRAM_NAME...\c" for PID in $PIDS ; do kill $PID done echo "SUCCESS!" ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/src/main/java/org/apache/rocketmq/hbase/source/Config.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.hbase.source; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Method; import java.util.Collections; import java.util.HashSet; import java.util.Properties; import java.util.Set; /** * Config is a convenience class that maintains all configuration properties that are needed for the application. */ public class Config { private static final String TOPICS_SEPARATOR = ","; private String nameserver = "localhost:9876"; private String consumerGroup = "HBASE_CONSUMER_GROUP"; private String messageModel = "BROADCASTING"; private String topics; private String zookeeperAddress = "localhost"; private int zookeeperPort = 2181; private long pullInterval = 1000; private int batchSize = 32; /** * Loads all properties from the configuration file. * * @throws IOException */ public void load() throws IOException { InputStream in = Config.class.getClassLoader().getResourceAsStream("rocketmq_hbase.conf"); Properties properties = new Properties(); properties.load(in); properties2Object(properties, this); } /** * Populate class fields with properties. * * @param p the properties instance * @param object this class instance */ private void properties2Object(final Properties p, final Object object) { Method[] methods = object.getClass().getMethods(); for (Method method : methods) { String mn = method.getName(); if (mn.startsWith("set")) { try { String tmp = mn.substring(4); String first = mn.substring(3, 4); String key = first.toLowerCase() + tmp; String property = p.getProperty(key); if (property != null) { Class[] pt = method.getParameterTypes(); if (pt != null && pt.length > 0) { String cn = pt[0].getSimpleName(); Object arg; if (cn.equals("int") || cn.equals("Integer")) { arg = Integer.parseInt(property); } else if (cn.equals("long") || cn.equals("Long")) { arg = Long.parseLong(property); } else if (cn.equals("double") || cn.equals("Double")) { arg = Double.parseDouble(property); } else if (cn.equals("boolean") || cn.equals("Boolean")) { arg = Boolean.parseBoolean(property); } else if (cn.equals("float") || cn.equals("Float")) { arg = Float.parseFloat(property); } else if (cn.equals("String")) { arg = property; } else { continue; } method.invoke(object, arg); } } } catch (Throwable ignored) { } } } } public String getNameserver() { return nameserver; } public String getConsumerGroup() { return consumerGroup; } public String getMessageModel() { return messageModel; } public Set getTopics() { final String[] topicsArr = topics.split(TOPICS_SEPARATOR); final Set topicsSet = new HashSet<>(); Collections.addAll(topicsSet, topicsArr); return topicsSet; } public String getZookeeperAddress() { return zookeeperAddress; } public int getZookeeperPort() { return zookeeperPort; } public long getPullInterval() { return pullInterval; } public int getBatchSize() { return batchSize; } public void setNameserver(String nameserver) { this.nameserver = nameserver; } public void setConsumerGroup(String consumerGroup) { this.consumerGroup = consumerGroup; } public void setMessageModel(String messageModel) { this.messageModel = messageModel; } public void setTopics(String topics) { this.topics = topics; } public void setZookeeperAddress(String zookeeperAddress) { this.zookeeperAddress = zookeeperAddress; } public void setZookeeperPort(int zookeeperPort) { this.zookeeperPort = zookeeperPort; } public void setPullInterval(long pullInterval) { this.pullInterval = pullInterval; } public void setBatchSize(int batchSize) { this.batchSize = batchSize; } } ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/src/main/java/org/apache/rocketmq/hbase/source/HBaseClient.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.hbase.source; import java.io.IOException; import java.util.ArrayList; import java.util.List; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.ConnectionFactory; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Table; import org.apache.rocketmq.common.message.MessageExt; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import static org.apache.hadoop.hbase.util.Bytes.toBytes; /** * This class represents the HBase client that effectively writes the messages to the corresponding HBase tables. */ public class HBaseClient { public static final byte[] COLUMN_FAMILY = toBytes("message"); private static final Logger logger = LoggerFactory.getLogger(HBaseClient.class); private String zookeeperAddress; private int zookeeperPort; private Connection connection; /** * Constructor. * * @param config the configuration */ public HBaseClient(Config config) { this.zookeeperAddress = config.getZookeeperAddress(); this.zookeeperPort = config.getZookeeperPort(); } /** * Starts the HBase client by opening a connection to the HBase server. * * @throws IOException */ public void start() throws IOException { final Configuration hbaseConfig = HBaseConfiguration.create(); hbaseConfig.set("hbase.zookeeper.quorum", zookeeperAddress); hbaseConfig.set("hbase.zookeeper.property.clientPort", Integer.toString(zookeeperPort)); connection = ConnectionFactory.createConnection(hbaseConfig); logger.info("HBase client started."); } /** * Writes messages into a specified HBase table. * * @param tableName * @param messages * @throws IOException */ public void put(String tableName, List messages) throws IOException { try (Table table = connection.getTable(TableName.valueOf(tableName))) { final List puts = new ArrayList<>(); for (MessageExt msg : messages) { final Put put = new Put(toBytes(msg.getMsgId())); put.addColumn(COLUMN_FAMILY, null, msg.getBody()); puts.add(put); } table.put(puts); } } /** * Stops the HBase client. * * @throws IOException */ public void stop() throws IOException { connection.close(); logger.info("HBase client stopped."); } } ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/src/main/java/org/apache/rocketmq/hbase/source/MessageProcessor.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.hbase.source; import java.io.IOException; import java.util.List; import java.util.Map; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.common.message.MessageExt; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * MessageProcessor is the main class that is responsible for managing the main work flow of pulling messages from * RocketMQ topics and writing them into HBase. */ public class MessageProcessor implements Runnable { private static final Logger logger = LoggerFactory.getLogger(MessageProcessor.class); private RocketMQConsumer consumer; private HBaseClient hbaseClient; private long pullInterval; private boolean on = false; /** * Constructor. * * @param config the configuration */ public MessageProcessor(Config config) { pullInterval = config.getPullInterval(); consumer = new RocketMQConsumer(config); hbaseClient = new HBaseClient(config); } /** * Starts the message processor by starting out the rocketmq consumer and the hbase client. * * @throws MQClientException * @throws IOException */ public void start() throws MQClientException, IOException { consumer.start(); hbaseClient.start(); on = true; final Thread thread = new Thread(this); thread.start(); logger.info("Message processor started."); } /** * This is the main method that runs in a separate thread and does the actual processing of pulling message from * rocketmq and writing them into hbase. */ @Override public void run() { Map> messagesPerTopic; while (on) { try { while ((messagesPerTopic = consumer.pull()) == null) { Thread.sleep(pullInterval); } for (Map.Entry> entry : messagesPerTopic.entrySet()) { final String topic = entry.getKey(); final List messages = entry.getValue(); hbaseClient.put(topic, messages); } } catch (Exception e) { logger.error("Error while processing messages.", e); } } consumer.stop(); try { hbaseClient.stop(); } catch (IOException e) { logger.error("HBase client failed to stop.", e); } logger.info("Message processor stopped."); } /** * Stops the message processor. */ public void stop() { on = false; } } ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/src/main/java/org/apache/rocketmq/hbase/source/RocketMQConsumer.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.hbase.source; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.rocketmq.client.consumer.DefaultMQPullConsumer; import org.apache.rocketmq.client.consumer.PullResult; import org.apache.rocketmq.client.consumer.PullStatus; import org.apache.rocketmq.client.exception.MQBrokerException; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.common.message.MessageExt; import org.apache.rocketmq.common.message.MessageQueue; import org.apache.rocketmq.common.protocol.heartbeat.MessageModel; import org.apache.rocketmq.remoting.exception.RemotingException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * This class represents the RocketMQ consumer that effectively pulls the messages from the RocketMQ topics. */ public class RocketMQConsumer { private static final Logger logger = LoggerFactory.getLogger(RocketMQConsumer.class); private DefaultMQPullConsumer consumer; private String namesrvAddr; private String consumerGroup; private MessageModel messageModel; private Set topics; private int batchSize; /** * Constructor. * * @param config the configuration */ public RocketMQConsumer(Config config) { this.namesrvAddr = config.getNameserver(); this.consumerGroup = config.getConsumerGroup(); this.messageModel = MessageModel.valueOf(config.getMessageModel()); this.topics = config.getTopics(); this.batchSize = config.getBatchSize(); } /** * Starts the rocketmq consumer. * * @throws MQClientException */ public void start() throws MQClientException { consumer = new DefaultMQPullConsumer(consumerGroup); consumer.setNamesrvAddr(namesrvAddr); consumer.setMessageModel(messageModel); consumer.setRegisterTopics(topics); consumer.start(); logger.info("RocketMQ consumer started."); } /** * Pulls messages from specified topics. * * @return a map containing a list of messages per topic * @throws MQClientException * @throws RemotingException * @throws InterruptedException * @throws MQBrokerException */ public Map> pull() throws MQClientException, RemotingException, InterruptedException, MQBrokerException { final Map> messagesPerTopic = new HashMap<>(); for (String topic : topics) { final Set msgQueues = consumer.fetchSubscribeMessageQueues(topic); for (MessageQueue msgQueue : msgQueues) { final long offset = getMessageQueueOffset(msgQueue); final PullResult pullResult = consumer.pull(msgQueue, null, offset, batchSize); if (pullResult.getPullStatus() == PullStatus.FOUND) { messagesPerTopic.put(topic, pullResult.getMsgFoundList()); logger.debug("Pulled {} messages", pullResult.getMsgFoundList().size()); } } } return messagesPerTopic.size() > 0 ? messagesPerTopic : null; } private long getMessageQueueOffset(MessageQueue queue) throws MQClientException { long offset = consumer.fetchConsumeOffset(queue, false); if (offset < 0) { offset = 0; } return offset; } /** * Stops the rocketmq consumer. */ public void stop() { consumer.shutdown(); logger.info("RocketMQ consumer stopped."); } } ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/src/main/java/org/apache/rocketmq/hbase/source/RocketMQSource.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.hbase.source; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * This class is the entry point for the RocketMQ source, which replicates RocketMQ topics to HBase tables. It assumes * that (i) each configured RocketMQ topic is maped to a HBase table with the same name; and (ii) the corresponding * HBase tables already exist. */ public class RocketMQSource { private Logger logger = LoggerFactory.getLogger(RocketMQSource.class); private Config config; public static void main(String[] args) { final RocketMQSource rocketMQSource = new RocketMQSource(); rocketMQSource.execute(); } /** * Executes this source indefinitely. */ public void execute() { try { config = new Config(); config.load(); final MessageProcessor processor = new MessageProcessor(config); processor.start(); } catch (Exception e) { logger.error("Error on starting RocketMQSource.", e); } } } ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/src/main/resources/logback.xml ================================================ %d{yyy-MM-dd HH:mm:ss,GMT+8} %p - %m%n UTF-8 ./logs/rocketmq_hbase.log ./logs/rocketmq_hbase.%i.log 1 10 100MB %d{yyy-MM-dd HH:mm:ss,GMT+8} %p - %m%n UTF-8 ./logs/position.log ./logs/position.%i.log 1 10 10MB %d{yyy-MM-dd HH:mm:ss,GMT+8} - %m%n UTF-8 ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/src/main/resources/rocketmq_hbase.conf ================================================ # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. topics= ================================================ FILE: rocketmq-hbase/rocketmq-hbase-source/src/test/java/org/apache/rocketmq/hbase/source/RocketMQSourceTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.hbase.source; import java.io.IOException; import java.io.UnsupportedEncodingException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.HBaseTestingUtility; import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.ConnectionFactory; import org.apache.hadoop.hbase.client.Get; import org.apache.hadoop.hbase.client.HBaseAdmin; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.util.Bytes; import org.apache.rocketmq.broker.BrokerController; import org.apache.rocketmq.client.exception.MQBrokerException; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.client.producer.DefaultMQProducer; import org.apache.rocketmq.client.producer.SendResult; import org.apache.rocketmq.common.BrokerConfig; import org.apache.rocketmq.common.MQVersion; import org.apache.rocketmq.common.MixAll; import org.apache.rocketmq.common.message.Message; import org.apache.rocketmq.common.namesrv.NamesrvConfig; import org.apache.rocketmq.namesrv.NamesrvController; import org.apache.rocketmq.remoting.exception.RemotingException; import org.apache.rocketmq.remoting.netty.NettyClientConfig; import org.apache.rocketmq.remoting.netty.NettyServerConfig; import org.apache.rocketmq.remoting.protocol.RemotingCommand; import org.apache.rocketmq.store.config.MessageStoreConfig; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import static org.apache.hadoop.hbase.util.Bytes.toBytes; import static org.junit.Assert.assertEquals; /** * This class tests the RocketMQ source by writing data from RocketMQ to HBase and reading it back. */ public class RocketMQSourceTest { private static final String NAMESERVER = "localhost:9876"; private static final String PRODUCER_GROUP_NAME = "HBASE_PRODUCER_GROUP_TEST"; private static final String ROCKETMQ_TOPIC = "rocketmq-hbase-topic-test"; private static final TableName TABLE_NAME = TableName.valueOf(ROCKETMQ_TOPIC); private static final Logger logger = LoggerFactory.getLogger(RocketMQSourceTest.class); private static NamesrvController namesrvController; private static BrokerController brokerController; private HBaseTestingUtility utility; private Configuration hbaseConf; @Before public void setUp() throws Exception { // start hbase server final Configuration config = HBaseConfiguration.create(); utility = new HBaseTestingUtility(config); utility.startMiniCluster(); hbaseConf = utility.getConfiguration(); // create HBase table createTable(); // start rocketmq server startMQ(); } @Test public void testRocketMQSource() throws Exception { // write data to rocketmq final String inMsg = "test-rocketmq-hbase-" + System.currentTimeMillis(); final String msgId; try { msgId = writeData(inMsg); logger.info("Message written to rocketmq (msgID: " + msgId + ")."); } catch (Exception e) { logger.error("Error while writing data.", e); throw new Exception("Error while writing data.", e); } // write data from rocketmq to hbase final Config config = new Config(); config.setNameserver(NAMESERVER); config.setTopics(ROCKETMQ_TOPIC); config.setZookeeperPort(utility.getZkCluster().getClientPort()); config.setPullInterval(0); final MessageProcessor messageProcessor = new MessageProcessor(config); try { messageProcessor.start(); } catch (Exception e) { logger.error("Error while starting message processor.", e); throw new Exception("Error while starting message processor.", e); } Thread.sleep(1000); messageProcessor.stop(); logger.info("Message processor completed successfully."); // read data from hbase final String readMsg; try { readMsg = readData(msgId); logger.info("Message read from HBase (msg: " + readMsg + ")."); } catch (Exception e) { logger.error("Error while reading data.", e); throw new Exception("Error while reading data.", e); } assertEquals(inMsg, readMsg); } @After public void tearDown() throws Exception { if (utility != null) { utility.shutdownMiniCluster(); } if (brokerController != null) { brokerController.shutdown(); } if (namesrvController != null) { namesrvController.shutdown(); } } /** * Creates the HBase table. * * @throws IOException */ private void createTable() throws IOException { try (HBaseAdmin hBaseAdmin = utility.getHBaseAdmin()) { final HTableDescriptor hTableDescriptor = new HTableDescriptor(TABLE_NAME); final HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(HBaseClient.COLUMN_FAMILY); hTableDescriptor.addFamily(hColumnDescriptor); hBaseAdmin.createTable(hTableDescriptor); } utility.waitUntilAllRegionsAssigned(TABLE_NAME); } /** * @param inMsg * @return * @throws MQClientException * @throws UnsupportedEncodingException * @throws RemotingException * @throws InterruptedException * @throws MQBrokerException */ private String writeData(String inMsg) throws MQClientException, UnsupportedEncodingException, RemotingException, InterruptedException, MQBrokerException { final DefaultMQProducer producer = new DefaultMQProducer(PRODUCER_GROUP_NAME); producer.setNamesrvAddr(NAMESERVER); try { producer.start(); final Message msg = new Message(ROCKETMQ_TOPIC, null, inMsg.getBytes("UTF-8")); final SendResult sendResult = producer.send(msg); logger.info("publish message : {}, sendResult:{}", msg, sendResult); return sendResult.getMsgId(); } finally { producer.shutdown(); } } /** * @param row * @return * @throws IOException */ private String readData(String row) throws IOException { try (Table hTable = ConnectionFactory.createConnection(hbaseConf).getTable(TABLE_NAME)) { final Get get = new Get(toBytes(row)); get.addFamily(HBaseClient.COLUMN_FAMILY); final Result result = hTable.get(get); final String resultStr = Bytes.toString(result.getValue(HBaseClient.COLUMN_FAMILY, null)); return resultStr; } } /** * This method starts the RocketMQ server. * * @throws Exception */ private static void startMQ() throws Exception { startNamesrv(); startBroker(); Thread.sleep(2000); } /** * This method starts the RocketMQ nameserver. * * @throws Exception */ private static void startNamesrv() throws Exception { NamesrvConfig namesrvConfig = new NamesrvConfig(); NettyServerConfig nettyServerConfig = new NettyServerConfig(); nettyServerConfig.setListenPort(9876); namesrvController = new NamesrvController(namesrvConfig, nettyServerConfig); boolean initResult = namesrvController.initialize(); if (!initResult) { namesrvController.shutdown(); throw new Exception("Name server controller failed to initialize."); } namesrvController.start(); } /** * This method starts the RocketMQ broker. * * @throws Exception */ private static void startBroker() throws Exception { System.setProperty(RemotingCommand.REMOTING_VERSION_KEY, Integer.toString(MQVersion.CURRENT_VERSION)); BrokerConfig brokerConfig = new BrokerConfig(); brokerConfig.setNamesrvAddr(NAMESERVER); brokerConfig.setBrokerId(MixAll.MASTER_ID); NettyServerConfig nettyServerConfig = new NettyServerConfig(); nettyServerConfig.setListenPort(10911); NettyClientConfig nettyClientConfig = new NettyClientConfig(); MessageStoreConfig messageStoreConfig = new MessageStoreConfig(); brokerController = new BrokerController(brokerConfig, nettyServerConfig, nettyClientConfig, messageStoreConfig); boolean initResult = brokerController.initialize(); if (!initResult) { brokerController.shutdown(); throw new Exception(); } brokerController.start(); } } ================================================ FILE: rocketmq-hbase/style/copyright/Apache.xml ================================================ ================================================ FILE: rocketmq-hbase/style/copyright/profiles_settings.xml ================================================ ================================================ FILE: rocketmq-hbase/style/rmq_checkstyle.xml ================================================ ================================================ FILE: rocketmq-hbase/style/rmq_codeStyle.xml ================================================ ================================================ FILE: rocketmq-iot-bridge/.gitignore ================================================ .idea target/ *.swp *.swo ================================================ FILE: rocketmq-iot-bridge/README.md ================================================ # IoT Bridge for Apache RocketMQ IoT Bridge for Apache RocketMQ is a solution to reliable and real-time message service for IoT devices. ## Main features - Multiple protocols support - MQTT - CoAP - Pluggable message storage - Pluggable subscription storage - Pluggable upstream data processing extensions ## Get Started ### Build from source 1. Clone the code ```shell git clone http://github.com/apache/rocketmq-externals ``` 2. Build the binary ```shell cd iot-bridge mvn clean package -DskipTests=true ``` 3. Try it Start the server ``` sh bin/server.sh start ``` Start the Consumer ``` sh bin/sample-consumer.sh ``` Start the Producer ``` sh bin/sample-producer.sh ``` ## Read More See the [documents](docs/index.md). ## License Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you 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. ================================================ FILE: rocketmq-iot-bridge/docs/architecture.md ================================================ # Architecture ![](images/architecture.png) As shown in above picture, the modules of the bridge are: - ConnectionManager: manage the connections between the client and bridge - Protocol Converter: translate the MQTT protocol packets to Bridge internal Message - Downstream Module: - receive messages from client - handle the *SUBSCRIBING* requests - push messages to *CLIENTS* according to TOPIC - forward messages to other *BRIDGES* if necessary - Message Store: - persistent MESSAGES which needs to be retained - query OFFLINE messages for any one client - query message by *MessageId* - Subscription Store: - query SUBSCRIBED clients by TOPIC - maintain the mapping from *TOPIC* to *CLIENTS* ================================================ FILE: rocketmq-iot-bridge/docs/index.md ================================================ # MQTT Bridge for Apache RocketMQ Documents - [architecture](architecture.md) - [RIP](https://docs.google.com/document/d/1G1-aJ74ZTjy_rxtJU3jm_YoICexNTdUVSR9E78K9xlo/edit?usp=sharing) ================================================ FILE: rocketmq-iot-bridge/docs-cn/architecture.md ================================================ # 架构设计 ![](images/architecture.png) 如上图所示，各个子模块职责如下： - Connection Manager: 管理客户端和Bridge之间的连接 - Protocol Converter：负责协议转换，将协议数据包转换成Bridge内部的Message - Downstream module：下行模块，负责 - 接收客户端（Producer）发送的消息 - 处理客户端（Consumer）的订阅请求 - 向客户端（Consumer）推送订阅的消息 - 向其他Bridge转发消息 - Upstream module：上行模块，负责将客户端发送的消息上报给外部系统，例如Flink，Spark - Message Store：消息存储模块，负责 - 持久化所有需要保存的消息 - 查询某个客户端所有的离线消息 - 根据消息Id查询某一条消息 - Subscription Store: 订阅消息存储模块，负责 - 根据topic查询订阅该topic的所有客户端 - 维护topic -- client list的映射关系 ================================================ FILE: rocketmq-iot-bridge/docs-cn/index.md ================================================ # Apache RocketMQ MQTT Bridge 文档索引 - [架构设计](architecture.md) - [RIP](https://docs.google.com/document/d/1G1-aJ74ZTjy_rxtJU3jm_YoICexNTdUVSR9E78K9xlo/edit?usp=sharing) ================================================ FILE: rocketmq-iot-bridge/pom.xml ================================================ 4.0.0 org.apache.rocketmq rocketmq-iot-bridge 0.0.1-SNAPSHOT jar rocketmq-iot-bridge ${project.version} io.netty netty-all 4.1.26.Final io.netty netty-codec-mqtt 4.1.26.Final org.eclipse.paho org.eclipse.paho.client.mqttv3 1.0.2 junit junit 4.12 test org.mockito mockito-all 1.9.5 test org.apache.commons commons-lang3 3.0 test org.slf4j slf4j-api 1.7.7 ch.qos.logback logback-classic 1.0.13 1.8 1.8 org.apache.maven.plugins maven-dependency-plugin copy-dependencies prepare-package copy-dependencies ${project.build.directory}/lib false false true org.apache.maven.plugins maven-jar-plugin true lib/ org.apache.rocketmq.iot.MQTTBridge org.apache.rat apache-rat-plugin 0.12 .gitignore .travis.yml CONTRIBUTING.md docs/*.md .github/** src/test/resources/certs/* src/test/**/*.log src/test/resources/META-INF/service/* */target/** */*.iml target/** **/org/apche/rocketmq.iot.example/** maven-checkstyle-plugin 2.17 verify verify style/rmq_checkstyle.xml UTF-8 true true false **/org/apache/rocketmq/iot/example/** check org.jacoco jacoco-maven-plugin 0.8.2 ${basedir}/target/coverage-reports/jacoco-unit.exec ${basedir}/target/coverage-reports/jacoco-unit.exec **/org/apache/rocketmq/iot/example/**/* **/org/apache/rocketmq/iot/common/util/**/* **/org/apache/rocketmq/iot/common/data/**/* **/org/apache/rocketmq/iot/common/configuration/**/* **/org/apache/rocketmq/iot/protocol/mqtt/constant/**/* jacoco-initialize prepare-agent check check BUNDLE INSTRUCTION COVEREDRATIO 0.80 BRANCH COVEREDRATIO 1.0 jacoco-site package report ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/MQTTBridge.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.ChannelPipeline; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.codec.mqtt.MqttDecoder; import io.netty.handler.codec.mqtt.MqttEncoder; import org.apache.rocketmq.iot.common.configuration.MQTTBridgeConfiguration; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageDispatcher; import org.apache.rocketmq.iot.connection.client.impl.ClientManagerImpl; import org.apache.rocketmq.iot.protocol.mqtt.handler.MqttConnectionHandler; import org.apache.rocketmq.iot.protocol.mqtt.handler.MqttIdleHandler; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttConnectMessageHandler; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttDisconnectMessageHandler; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttMessageForwarder; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttPingreqMessageHandler; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttSubscribeMessageHandler; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttUnsubscribeMessagHandler; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; import org.apache.rocketmq.iot.storage.subscription.impl.InMemorySubscriptionStore; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class MQTTBridge { private ServerBootstrap serverBootstrap; private NioEventLoopGroup bossGroup; private NioEventLoopGroup workerGroup; private MessageDispatcher messageDispatcher; private SubscriptionStore subscriptionStore; private ClientManager clientManager; private MqttConnectionHandler connectionHandler; private Logger logger = LoggerFactory.getLogger(MQTTBridge.class); public MQTTBridge() { init(); } private void init() { bossGroup = new NioEventLoopGroup(MQTTBridgeConfiguration.threadNumOfBossGroup()); workerGroup = new NioEventLoopGroup(MQTTBridgeConfiguration.threadNumOfWorkerGroup()); serverBootstrap = new ServerBootstrap(); serverBootstrap.group(bossGroup, workerGroup) .localAddress(MQTTBridgeConfiguration.port()) .channel(NioServerSocketChannel.class) .option(ChannelOption.SO_BACKLOG, MQTTBridgeConfiguration.socketBacklog()) .childHandler(new ChannelInitializer() { @Override protected void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast("mqtt-decoder", new MqttDecoder()); pipeline.addLast("mqtt-encoder", MqttEncoder.INSTANCE); pipeline.addLast("channel-idle-handler", new MqttIdleHandler()); pipeline.addLast("message-dispatcher", messageDispatcher); pipeline.addLast("connection-manager", connectionHandler); } }); subscriptionStore = new InMemorySubscriptionStore(); clientManager = new ClientManagerImpl(); messageDispatcher = new MessageDispatcher(clientManager); connectionHandler = new MqttConnectionHandler(clientManager, subscriptionStore); registerMessageHandlers(); } private void registerMessageHandlers() { messageDispatcher.registerHandler(Message.Type.MQTT_CONNECT, new MqttConnectMessageHandler(clientManager)); messageDispatcher.registerHandler(Message.Type.MQTT_DISCONNECT, new MqttDisconnectMessageHandler(clientManager)); messageDispatcher.registerHandler(Message.Type.MQTT_PUBLISH, new MqttMessageForwarder(subscriptionStore)); // TODO qos 1/2 PUBLISH // TODO qos 1: PUBACK // TODO qos 2: PUBREC // TODO qos 2: PUBREL // TODO qos 2: PUBCOMP messageDispatcher.registerHandler(Message.Type.MQTT_PINGREQ, new MqttPingreqMessageHandler()); messageDispatcher.registerHandler(Message.Type.MQTT_SUBSCRIBE, new MqttSubscribeMessageHandler(subscriptionStore)); messageDispatcher.registerHandler(Message.Type.MQTT_UNSUBSCRIBE, new MqttUnsubscribeMessagHandler(subscriptionStore)); } public void start() { try { ChannelFuture channelFuture = serverBootstrap.bind().sync(); channelFuture.channel().closeFuture().sync(); } catch (Exception e) { logger.error("fail to start the MQTTServer." + e); } finally { logger.info("shutdown the MQTTServer"); shutdown(); } } public void shutdown() { bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } public static void main(String [] args) { MQTTBridge server = new MQTTBridge(); server.start(); } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/common/configuration/ChannelConfiguration.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.common.configuration; import io.netty.util.AttributeKey; public class ChannelConfiguration { public static final String CHANNEL_IDLE_TIME = "channelIdleTime"; public static final AttributeKey CHANNEL_IDLE_TIME_ATTRIBUTE_KEY = AttributeKey.valueOf(CHANNEL_IDLE_TIME); } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/common/configuration/MQTTBridgeConfiguration.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.common.configuration; import java.util.Properties; public class MQTTBridgeConfiguration { private Properties properties; public static final String MQTT_PORT_PROPERTY = "iot.mqtt.port"; public static final String DEFAULT_MQTT_PORT = "1883"; public static final String MQTT_HOST_PROPERTY = "iot.mqtt.host"; public static final String DEFAULT_MQTT_HOST = "127.0.0.1"; public static final String MQTT_SOCKET_BACKLOG = "iot.mqtt.socket.backlog"; public static final String DEFAULT_SOCKET_BACKLOG = "1024"; public static final Integer DEFAULT_THREAD_NUM_OF_BOSS_GROUP = 1; public static final Integer DEFAULT_THREAD_NUM_OF_WORKER_GROUP = 32; public static Integer port() { return Integer.valueOf(System.getProperty(MQTT_PORT_PROPERTY, DEFAULT_MQTT_PORT)); } public static String host() { return System.getProperty(MQTT_HOST_PROPERTY, DEFAULT_MQTT_HOST); } public static Integer socketBacklog() { return Integer.valueOf(System.getProperty(MQTT_SOCKET_BACKLOG, DEFAULT_SOCKET_BACKLOG)); } public static Integer threadNumOfBossGroup() { return DEFAULT_THREAD_NUM_OF_BOSS_GROUP; } public static Integer threadNumOfWorkerGroup() { return DEFAULT_THREAD_NUM_OF_WORKER_GROUP; } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/common/data/Message.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.common.data; import java.util.Map; import org.apache.rocketmq.iot.connection.client.Client; public class Message { public enum Type { MQTT_CONNECT, /* the MQTT CONNECT message from the client */ MQTT_CONNACK, /* the MQTT CONNACK message from the client */ MQTT_PUBLISH,/* the MQTT PUBLISH message from the client */ MQTT_PUBACK,/* the MQTT PUBACK message from the client */ MQTT_PUBREC,/* the MQTT PUBREC message from the client */ MQTT_PUBREL,/* the MQTT PUBREL message from the client */ MQTT_PUBCOMP,/* the MQTT PUBCOMP message from the client */ MQTT_SUBSCRIBE,/* the MQTT SUBSCRIBE message from the client */ MQTT_SUBACK,/* the MQTT SUBACK message from the client */ MQTT_UNSUBSCRIBE,/* the MQTT UNSUBSCRIBE message from the client */ MQTT_UNSUBACK,/* the MQTT UNSUBACK message from the client */ MQTT_PINGREQ,/* the MQTT PINGREQ message from the client */ MQTT_PINGRESP,/* the MQTT PINGRESP message will be sent to the client */ MQTT_DISCONNECT,/* the MQTT DISCONNECT message from the client */ MQTT_SEND,/* the MQTT PUBLISH message will be sent to the client */ } private String id; private Map headers; private Type type; private Object payload; private Client client; private String topic; public String getId() { return id; } public void setId(String id) { this.id = id; } public Map getHeaders() { return headers; } public void setHeaders(Map headers) { this.headers = headers; } public Type getType() { return type; } public void setType(Type type) { this.type = type; } public Object getPayload() { return payload; } public void setPayload(Object payload) { this.payload = payload; } public Client getClient() { return client; } public void setClient(Client client) { this.client = client; } public String getTopic() { return topic; } public void setTopic(String topic) { this.topic = topic; } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/common/util/MessageUtil.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.common.util; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.handler.codec.mqtt.MqttConnAckMessage; import io.netty.handler.codec.mqtt.MqttConnAckVariableHeader; import io.netty.handler.codec.mqtt.MqttConnectMessage; import io.netty.handler.codec.mqtt.MqttConnectReturnCode; import io.netty.handler.codec.mqtt.MqttFixedHeader; import io.netty.handler.codec.mqtt.MqttMessage; import io.netty.handler.codec.mqtt.MqttMessageIdVariableHeader; import io.netty.handler.codec.mqtt.MqttMessageType; import io.netty.handler.codec.mqtt.MqttPubAckMessage; import io.netty.handler.codec.mqtt.MqttPublishMessage; import io.netty.handler.codec.mqtt.MqttPublishVariableHeader; import io.netty.handler.codec.mqtt.MqttQoS; import io.netty.handler.codec.mqtt.MqttSubAckMessage; import io.netty.handler.codec.mqtt.MqttSubAckPayload; import io.netty.handler.codec.mqtt.MqttSubscribeMessage; import io.netty.handler.codec.mqtt.MqttUnsubAckMessage; import io.netty.handler.codec.mqtt.MqttUnsubscribeMessage; import org.apache.rocketmq.iot.protocol.mqtt.constant.MqttConstant; import org.apache.rocketmq.iot.common.data.Message; public class MessageUtil { public static final String MQTT_QOS_LEVEL = "MQTT_QOS_LEVEL"; public static final String MQTT_IS_RETAIN = "MQTT_IS_RETAIN"; public static final String MQTT_PACKET_ID = "MQTT_PACKET_ID"; public static final String MQTT_TOPIC_NAME = "MQTT_TOPIC_NAME"; public static final String MQTT_REMAINING_LENGTH = "MQTT_REMAINING_LENGTH"; public static final String MQTT_IS_DUP = "MQTT_IS_DUP"; public static final String MQTT_CLIENT_NAME = "MQTT_CLIENT_NAME"; public static final String MQTT_IS_CLEAN_SESSION = "MQTT_IS_CLEAN_SESSION"; public static final String MQTT_KEEP_ALIVE_TIME = "MQTT_KEEP_ALIVE_TIME"; public static final String MQTT_PROTOCOL_VERSION = "MQTT_PROTOCOL_VERSION"; public static MqttSubAckMessage getMqttSubackMessage(MqttSubscribeMessage message, MqttSubAckPayload payload) { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.SUBACK, false, message.fixedHeader().qosLevel(), message.fixedHeader().isRetain(), 0 ); MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(message.variableHeader().messageId()); return new MqttSubAckMessage(fixedHeader, variableHeader, payload); } public static MqttPublishMessage getMqttPublishMessage(Message message, boolean isDup) { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBLISH, isDup, MqttQoS.valueOf(message.getHeaders().get(MQTT_QOS_LEVEL)), Boolean.valueOf(message.getHeaders().get(MQTT_IS_RETAIN)), Integer.valueOf(message.getHeaders().get(MQTT_REMAINING_LENGTH)) ); MqttPublishVariableHeader variableHeader = new MqttPublishVariableHeader( message.getHeaders().get(MQTT_TOPIC_NAME), Integer.valueOf(message.getHeaders().get(MQTT_PACKET_ID)) ); ByteBuf buf = Unpooled.buffer(); buf.writeBytes((byte[]) message.getPayload()); return new MqttPublishMessage(fixedHeader, variableHeader, buf); } public static MqttConnAckMessage getMqttConnackMessage(MqttConnectMessage message, MqttConnectReturnCode returnCode) { assert message.fixedHeader().messageType() == MqttMessageType.CONNECT; MqttConnAckVariableHeader variableHeader = new MqttConnAckVariableHeader( returnCode, message.variableHeader().isCleanSession() ); MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.CONNACK, message.fixedHeader().isDup(), message.fixedHeader().qosLevel(), message.fixedHeader().isRetain(), 0); return new MqttConnAckMessage(fixedHeader, variableHeader); } public static MqttPubAckMessage getMqttPubackMessage(MqttPublishMessage message) { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBACK, message.fixedHeader().isDup(), message.fixedHeader().qosLevel(), message.fixedHeader().isRetain(), message.fixedHeader().remainingLength() ); return new MqttPubAckMessage(fixedHeader, MqttMessageIdVariableHeader.from(message.variableHeader().packetId())); } public static MqttMessage getMqttPubrecMessage(MqttPublishMessage message) { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBREC, message.fixedHeader().isDup(), message.fixedHeader().qosLevel(), message.fixedHeader().isRetain(), message.fixedHeader().remainingLength() ); return new MqttMessage(fixedHeader); } public static MqttMessage getMqttPubrelMessage(MqttMessage message) { assert message.fixedHeader().messageType() == MqttMessageType.PUBREC; MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBREL, message.fixedHeader().isDup(), message.fixedHeader().qosLevel(), message.fixedHeader().isRetain(), message.fixedHeader().remainingLength() ); return new MqttMessage(fixedHeader); } public static MqttMessage getMqttPubcompMessage(MqttMessage message) { assert message.fixedHeader().messageType() == MqttMessageType.PUBREL; MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBCOMP, message.fixedHeader().isDup(), message.fixedHeader().qosLevel(), message.fixedHeader().isRetain(), message.fixedHeader().remainingLength() ); return new MqttMessage(fixedHeader); } public static MqttMessage getMqttPingrespMessage(MqttMessage message) { assert message.fixedHeader().messageType() == MqttMessageType.PINGREQ; MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PINGRESP, message.fixedHeader().isDup(), message.fixedHeader().qosLevel(), message.fixedHeader().isRetain(), 0 ); return new MqttMessage(fixedHeader); } public static MqttUnsubAckMessage getMqttUnsubackMessage(MqttUnsubscribeMessage message) { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.UNSUBACK, message.fixedHeader().isDup(), message.fixedHeader().qosLevel(), message.fixedHeader().isRetain(), 0 ); MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(message.variableHeader().messageId()); return new MqttUnsubAckMessage(fixedHeader, variableHeader); } public static int actualQos(int qos) { return Math.min(MqttConstant.MAX_SUPPORTED_QOS, qos); } public static Message getMessage(MqttMessage mqttMessage) { Message message = new Message(); message.setPayload(mqttMessage); switch (mqttMessage.fixedHeader().messageType()) { case CONNECT: message.setType(Message.Type.MQTT_CONNECT); break; case CONNACK: message.setType(Message.Type.MQTT_CONNACK); break; case PUBLISH: message.setType(Message.Type.MQTT_PUBLISH); break; case PUBACK: message.setType(Message.Type.MQTT_PUBACK); break; case PUBREC: message.setType(Message.Type.MQTT_PUBREC); break; case PUBREL: message.setType(Message.Type.MQTT_PUBREL); break; case PUBCOMP: message.setType(Message.Type.MQTT_PUBCOMP); case SUBSCRIBE: message.setType(Message.Type.MQTT_SUBSCRIBE); break; case SUBACK: message.setType(Message.Type.MQTT_SUBACK); break; case UNSUBSCRIBE: message.setType(Message.Type.MQTT_UNSUBSCRIBE); break; case UNSUBACK: message.setType(Message.Type.MQTT_UNSUBACK); break; case PINGREQ: message.setType(Message.Type.MQTT_PINGREQ); break; case PINGRESP: message.setType(Message.Type.MQTT_PINGRESP); break; case DISCONNECT: message.setType(Message.Type.MQTT_DISCONNECT); break; default: } return message; } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/connection/client/Client.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.connection.client; import io.netty.channel.ChannelHandlerContext; public class Client { private String id; private ChannelHandlerContext ctx; private boolean connected; public String getId() { return id; } public void setId(String id) { this.id = id; } public ChannelHandlerContext getCtx() { return ctx; } public void setCtx(ChannelHandlerContext ctx) { this.ctx = ctx; } public boolean isConnected() { return connected; } public void setConnected(boolean connected) { this.connected = connected; } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/connection/client/ClientManager.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.connection.client; import io.netty.channel.Channel; public interface ClientManager { /** * Get the Client by its channel * @param channel * @return the Client which connects to the bridge with the channel, return null if */ public Client get(Channel channel); /** * Put the Client by its channel * @param channel the channel by which the Client connects to the server * @param client */ public void put(Channel channel, Client client); /** * Remove the Client by its channel usually the channel is disconnected * @param channel * @return the removed client, if the client doesn't exist return null */ public Client remove(Channel channel); } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/connection/client/impl/ClientManagerImpl.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.connection.client.impl; import io.netty.channel.Channel; import java.util.concurrent.ConcurrentHashMap; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.connection.client.ClientManager; public class ClientManagerImpl implements ClientManager { private ConcurrentHashMap channel2Client = new ConcurrentHashMap<>(); @Override public Client get(Channel channel) { return channel2Client.get(channel); } @Override public void put(Channel channel, Client client) { channel2Client.put(channel, client); } @Override public Client remove(Channel channel) { return channel2Client.remove(channel); } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/example/MqttSampleConsumer.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.example; import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken; import org.eclipse.paho.client.mqttv3.MqttCallback; import org.eclipse.paho.client.mqttv3.MqttClient; import org.eclipse.paho.client.mqttv3.MqttConnectOptions; import org.eclipse.paho.client.mqttv3.MqttException; import org.eclipse.paho.client.mqttv3.MqttMessage; import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class MqttSampleConsumer { private static Logger log = LoggerFactory.getLogger(MqttSampleConsumer.class); public static void main(String[] args) { String topic = "mqtt-sample"; int qos = 0; String broker = "tcp://127.0.0.1:1883"; String clinetId = "JavaSampleConsumer"; MemoryPersistence persistence = new MemoryPersistence(); { try { MqttClient sampleClient = new MqttClient(broker, clinetId, persistence); MqttConnectOptions connectOptions = new MqttConnectOptions(); connectOptions.setCleanSession(true); log.info("Connecting to broker: " + broker); sampleClient.connect(connectOptions); log.info("Connected"); sampleClient.setCallback(new MqttCallback() { @Override public void connectionLost(Throwable throwable) { } @Override public void messageArrived(String s, MqttMessage message) throws Exception { System.exit(0); } @Override public void deliveryComplete(IMqttDeliveryToken token) { } }); sampleClient.subscribe(topic, qos); } catch (MqttException me) { log.error("reason " + me.getReasonCode()); log.error("msg " + me.getMessage()); log.error("loc " + me.getLocalizedMessage()); log.error("cause " + me.getCause()); log.error("excep " + me); me.printStackTrace(); System.exit(1); } } } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/example/MqttSampleProducer.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.example; import org.eclipse.paho.client.mqttv3.MqttClient; import org.eclipse.paho.client.mqttv3.MqttConnectOptions; import org.eclipse.paho.client.mqttv3.MqttException; import org.eclipse.paho.client.mqttv3.MqttMessage; import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class MqttSampleProducer { private static Logger log = LoggerFactory.getLogger(MqttSampleProducer.class); public static void main(String[] args) { String topic = "mqtt-sample"; String messageContent = "hello mqtt"; int qos = 0; String broker = "tcp://127.0.0.1:1883"; String clientId = "JavaSampleProducer"; MemoryPersistence persistence = new MemoryPersistence(); try { MqttClient sampleClient = new MqttClient(broker, clientId, persistence); MqttConnectOptions connOpts = new MqttConnectOptions(); connOpts.setCleanSession(true); log.info("Connecting to broker: " + broker); sampleClient.connect(connOpts); log.info("Connected"); log.info("Publishing message: " + messageContent); MqttMessage message = new MqttMessage(messageContent.getBytes()); message.setQos(qos); sampleClient.publish(topic, message); log.info("Message published"); sampleClient.disconnect(); log.info("Disconnected"); System.exit(0); } catch (MqttException me) { log.error("reason " + me.getReasonCode()); log.error("msg " + me.getMessage()); log.error("loc " + me.getLocalizedMessage()); log.error("cause " + me.getCause()); log.error("excep " + me); me.printStackTrace(); System.exit(1); } } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/constant/MqttConstant.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.constant; public class MqttConstant { public static final int MAX_SUPPORTED_QOS = 0; public static final String SUBSCRIPTION_FLAG_PLUS = "+"; public static final String SUBSCRIPTION_FLAG_SHARP = "#"; public static final String SUBSCRIPTION_SEPARATOR = "/"; } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/data/Bridge.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.data; import io.netty.channel.Channel; public class Bridge { private String id; private Channel channel; } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/data/MqttClient.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.data; import org.apache.rocketmq.iot.connection.client.Client; public class MqttClient extends Client { private boolean isCleanSession = true; public boolean isCleanSession() { return isCleanSession; } public void setCleanSession(boolean cleanSession) { isCleanSession = cleanSession; } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/data/Subscription.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.data; public class Subscription { private String id; private MqttClient client; private int qos; public MqttClient getClient() { return client; } public int getQos() { return qos; } public String getId() { return id; } public static class Builder { Subscription subscription = new Subscription(); public Subscription build() { return subscription; } public Builder client(MqttClient client) { subscription.client = client; subscription.id = client.getId(); return this; } public Builder qos(int qos) { subscription.qos = qos; return this; } public static Builder newBuilder() { return new Builder(); } } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/event/DisconnectChannelEvent.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.event; import io.netty.channel.Channel; public class DisconnectChannelEvent { private Channel channel; public DisconnectChannelEvent(Channel channel) { this.channel = channel; } public Channel getChannel() { return channel; } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/MessageDispatcher.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler; import io.netty.channel.ChannelHandler; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import io.netty.handler.codec.mqtt.MqttMessage; import java.util.HashMap; import java.util.Map; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.common.util.MessageUtil; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; @ChannelHandler.Sharable public class MessageDispatcher extends SimpleChannelInboundHandler { private Map type2handler = new HashMap<>(); private ClientManager clientManager; public MessageDispatcher(ClientManager clientManager) { this.clientManager = clientManager; } public void registerHandler(Message.Type type, MessageHandler handler) { type2handler.put(type, handler); } private void dispatch(Message message) { Message.Type type = message.getType(); if (!type2handler.containsKey(type)) { return; } type2handler.get(type).handleMessage(message); } @Override protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception { if (!(msg instanceof MqttMessage)) { return; } Client client = clientManager.get(ctx.channel()); if (client == null) { client = new MqttClient(); client.setCtx(ctx); clientManager.put(ctx.channel(), client); } MqttMessage mqttMessage = (MqttMessage) msg; Message message = MessageUtil.getMessage(mqttMessage); message.setClient(client); dispatch(message); } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/MessageHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler; import org.apache.rocketmq.iot.common.data.Message; public interface MessageHandler { /** * Handle message from client * * @param message */ void handleMessage(Message message); } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/MqttConnectionHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler; import io.netty.channel.Channel; import io.netty.channel.ChannelHandler; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.handler.timeout.IdleState; import io.netty.handler.timeout.IdleStateEvent; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.event.DisconnectChannelEvent; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @ChannelHandler.Sharable public class MqttConnectionHandler extends ChannelInboundHandlerAdapter { private static final Logger log = LoggerFactory.getLogger(MqttConnectionHandler.class); private ClientManager clientManager; private SubscriptionStore subscriptionStore; public MqttConnectionHandler(ClientManager clientManager, SubscriptionStore subscriptionStore) { this.clientManager = clientManager; this.subscriptionStore = subscriptionStore; } @Override public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception { if (evt instanceof IdleStateEvent) { IdleStateEvent idleStateEvent = (IdleStateEvent) evt; if (IdleState.ALL_IDLE.equals(idleStateEvent.state())) { doDisconnect(ctx.channel()); } } else if (evt instanceof DisconnectChannelEvent) { DisconnectChannelEvent disconnectChannelEvent = (DisconnectChannelEvent) evt; doDisconnect(disconnectChannelEvent.getChannel()); } ctx.fireUserEventTriggered(evt); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { Client client = clientManager.get(ctx.channel()); String clientId = client != null ? client.getId() : "null"; doDisconnect(ctx.channel()); log.debug("clientId:{} netty exception caught from {}", clientId, ctx.channel(), cause); } /** * disconnect the channel, save the Subscription of the client which the channel belongs to if CleanSession * if set to false, otherwise discard them * * @param channel */ private void doDisconnect(Channel channel) { if (channel == null) { return; } MqttClient client = (MqttClient) clientManager.get(channel); if (client != null) { if (client.isCleanSession()) { subscriptionStore.getTopicFilters(client.getId()).forEach(filter -> { subscriptionStore.getTopics(filter).forEach(topic -> { subscriptionStore.remove(topic, client); }); }); clientManager.remove(channel); } else { // TODO support Sticky Session } } channel.close(); } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/MqttIdleHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler; import io.netty.channel.ChannelDuplexHandler; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelFutureListener; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelPromise; import io.netty.handler.timeout.IdleStateEvent; import io.netty.util.concurrent.EventExecutor; import io.netty.util.concurrent.ScheduledFuture; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; import org.apache.rocketmq.iot.common.configuration.ChannelConfiguration; public class MqttIdleHandler extends ChannelDuplexHandler { private static final long MIN_TIMEOUT_NANOS = TimeUnit.MILLISECONDS.toNanos(1); private volatile long lastReadTimeNanos; private volatile long lastWriteTimeNanos; private volatile long allIdleTimeNanos = 0; private volatile ScheduledFuture allIdleTimeoutFuture; boolean firstAllIdleEvent = true; public enum State { NONE, INITIALIZED, DESTROYED, READING }; private volatile AtomicReference state = new AtomicReference<>(); public MqttIdleHandler() { this(0); } public MqttIdleHandler(long allIdleTimeNanos) { this.allIdleTimeNanos = allIdleTimeNanos; state.set(State.NONE); } private final ChannelFutureListener writeListener = new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { lastWriteTimeNanos = System.nanoTime(); firstAllIdleEvent = true; } }; @Override public void handlerAdded(ChannelHandlerContext ctx) throws Exception { if (ctx.channel().isActive() && ctx.channel().isRegistered()) { initialize(ctx); } } @Override public void handlerRemoved(ChannelHandlerContext ctx) throws Exception { destroy(); } @Override public void channelRegistered(ChannelHandlerContext ctx) throws Exception { if (ctx.channel().isActive()) { initialize(ctx); } super.channelRegistered(ctx); } @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { initialize(ctx); super.channelActive(ctx); } @Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { destroy(); super.channelInactive(ctx); } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { if (allIdleTimeNanos > 0) { state.set(State.READING); firstAllIdleEvent = true; } ctx.fireChannelRead(msg); } @Override public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { if (state.get() == State.NONE) { Integer idleTime = ctx.channel().attr(ChannelConfiguration.CHANNEL_IDLE_TIME_ATTRIBUTE_KEY).get(); reDoInit(ctx, idleTime); } state.set(State.INITIALIZED); ctx.fireChannelReadComplete(); } @Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (allIdleTimeNanos > 0) { ChannelPromise unvoidPromise = promise.unvoid(); unvoidPromise.addListener(writeListener); ctx.write(msg, unvoidPromise); } else { ctx.write(msg, promise); } } private void initialize(ChannelHandlerContext ctx) { if (state.get() != State.NONE) { return; } state.set(State.INITIALIZED); EventExecutor loop = ctx.executor(); lastReadTimeNanos = lastWriteTimeNanos = System.nanoTime(); if (allIdleTimeNanos > 0) { loop.schedule(new AllIdleTimeoutTask(ctx), allIdleTimeNanos, TimeUnit.SECONDS); } } private void destroy() { state.set(State.DESTROYED); if (allIdleTimeoutFuture != null) { allIdleTimeoutFuture.cancel(false); allIdleTimeoutFuture = null; } } private void reDoInit(ChannelHandlerContext ctx, Integer idleTime) { state.set(State.INITIALIZED); destroy(); allIdleTimeNanos = Math.max(TimeUnit.SECONDS.toNanos(idleTime), MIN_TIMEOUT_NANOS); state.set(State.NONE); initialize(ctx); } protected void channelIdle(ChannelHandlerContext ctx, IdleStateEvent event) throws Exception { ctx.fireUserEventTriggered(event); } private final class AllIdleTimeoutTask implements Runnable { private final ChannelHandlerContext ctx; public AllIdleTimeoutTask(ChannelHandlerContext ctx) { this.ctx = ctx; } @Override public void run() { if (!ctx.channel().isOpen()) { return; } long nextDelay = allIdleTimeNanos; if (state.get() != State.READING) { nextDelay -= System.nanoTime() - Math.max(lastReadTimeNanos, lastWriteTimeNanos); } if (nextDelay < 0) { /** * Both reader and writer are idle, * set a new timeout and notify the callback */ allIdleTimeoutFuture = ctx.executor().schedule( this, allIdleTimeNanos, TimeUnit.NANOSECONDS ); try { IdleStateEvent event; if (firstAllIdleEvent) { firstAllIdleEvent = false; event = IdleStateEvent.FIRST_ALL_IDLE_STATE_EVENT; } else { event = IdleStateEvent.ALL_IDLE_STATE_EVENT; } channelIdle(ctx, event); } catch (Throwable throwable) { ctx.fireExceptionCaught(throwable); } } else { allIdleTimeoutFuture = ctx.executor().schedule(this, nextDelay, TimeUnit.NANOSECONDS); } } } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/SendCallback.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream; import io.netty.handler.codec.mqtt.MqttMessage; public interface SendCallback { /** * Do something in the callback when the message is sent to the client successfully * @param message the message sent to the client */ void onSuccess(MqttMessage message); /** * Do something in the callback when the message is sent to the client exceptionally * @param message the message sent to the client */ void onException(MqttMessage message, Exception e); } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttConnectMessageHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.mqtt.MqttConnAckMessage; import io.netty.handler.codec.mqtt.MqttConnectMessage; import io.netty.handler.codec.mqtt.MqttConnectReturnCode; import org.apache.rocketmq.iot.common.configuration.ChannelConfiguration; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.event.DisconnectChannelEvent; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; import org.apache.rocketmq.iot.common.util.MessageUtil; public class MqttConnectMessageHandler implements MessageHandler { private static final int MIN_AVAILABLE_VERSION = 3; private static final int MAX_AVAILABLE_VERSION = 4; private ClientManager clientManager; public MqttConnectMessageHandler(ClientManager clientManager) { this.clientManager = clientManager; } @Override public void handleMessage(Message message) { MqttClient client = (MqttClient) message.getClient(); MqttConnectMessage connectMessage = (MqttConnectMessage) message.getPayload(); MqttConnectReturnCode returnCode; MqttConnAckMessage ackMessage; ChannelHandlerContext ctx = client.getCtx(); if (!isClientIdValid(connectMessage.payload().clientIdentifier())) { returnCode = MqttConnectReturnCode.CONNECTION_REFUSED_IDENTIFIER_REJECTED; } else if (!checkUsername(connectMessage.payload().userName()) || !checkPassword(connectMessage.payload().passwordInBytes())) { returnCode = MqttConnectReturnCode.CONNECTION_REFUSED_BAD_USER_NAME_OR_PASSWORD; } else if (!isAuthorized(connectMessage)) { returnCode = MqttConnectReturnCode.CONNECTION_REFUSED_NOT_AUTHORIZED; } else if (client.isConnected()) { // protocol violation and disconnect ctx.fireUserEventTriggered(new DisconnectChannelEvent(ctx.channel())); return; } else if (!isServiceAviable(connectMessage)) { returnCode = MqttConnectReturnCode.CONNECTION_REFUSED_SERVER_UNAVAILABLE; } else { client.setId(connectMessage.payload().clientIdentifier()); client.setConnected(true); client.setCleanSession(connectMessage.variableHeader().isCleanSession()); ctx.channel().attr(ChannelConfiguration.CHANNEL_IDLE_TIME_ATTRIBUTE_KEY).set(connectMessage.variableHeader().keepAliveTimeSeconds()); returnCode = MqttConnectReturnCode.CONNECTION_ACCEPTED; } ackMessage = MessageUtil.getMqttConnackMessage(connectMessage, returnCode); ctx.writeAndFlush(ackMessage); } private boolean isServiceAviable(MqttConnectMessage connectMessage) { int version = connectMessage.variableHeader().version(); return version >= MIN_AVAILABLE_VERSION && version <= MAX_AVAILABLE_VERSION; } private boolean checkPassword(byte[] bytes) { return true; } private boolean checkUsername(String s) { return true; } private boolean isAuthorized(MqttConnectMessage message) { return true; } private boolean isClientIdValid(String s) { return true; } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttDisconnectMessageHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; public class MqttDisconnectMessageHandler implements MessageHandler { private ClientManager clientManager; public MqttDisconnectMessageHandler(ClientManager clientManager) { this.clientManager = clientManager; } /** * handle the DISCONNECT message from the client *
    *
  1. discard the Will Message and Will Topic
    2. *
  2. remove the client from the ClientManager
    3. *
  3. disconnect the connection
    4. *
* @param message * @return */ @Override public void handleMessage(Message message) { // TODO discard the Will Message and Will Topic clientManager.remove(message.getClient().getCtx().channel()); message.getClient().getCtx().disconnect(); } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttMessageForwarder.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.handler.codec.mqtt.MqttFixedHeader; import io.netty.handler.codec.mqtt.MqttMessageType; import io.netty.handler.codec.mqtt.MqttPublishMessage; import io.netty.handler.codec.mqtt.MqttPublishVariableHeader; import io.netty.handler.codec.mqtt.MqttQoS; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.protocol.mqtt.data.Subscription; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; import org.apache.rocketmq.iot.common.util.MessageUtil; public class MqttMessageForwarder implements MessageHandler { private SubscriptionStore subscriptionStore; public MqttMessageForwarder(SubscriptionStore subscriptionStore) { this.subscriptionStore = subscriptionStore; } /** * handle PUBLISH message from client * * @param message * @return whether the message is handled successfully */ @Override public void handleMessage(Message message) { MqttPublishMessage publishMessage = (MqttPublishMessage) message.getPayload(); String topic = publishMessage.variableHeader().topicName(); if (!subscriptionStore.hasTopic(topic)) { subscriptionStore.addTopic(topic); } for (Subscription subscription: subscriptionStore.get(publishMessage.variableHeader().topicName())) { ByteBuf buf = Unpooled.buffer(); byte [] bytes = new byte[publishMessage.payload().readableBytes()]; publishMessage.payload().getBytes(0, bytes); buf.writeBytes(bytes); MqttPublishMessage msg = new MqttPublishMessage( new MqttFixedHeader( MqttMessageType.PUBLISH, publishMessage.fixedHeader().isDup(), MqttQoS.valueOf(MessageUtil.actualQos(publishMessage.fixedHeader().qosLevel().value())), publishMessage.fixedHeader().isRetain(), publishMessage.fixedHeader().remainingLength() ), new MqttPublishVariableHeader( publishMessage.variableHeader().topicName(), publishMessage.variableHeader().packetId() ), buf ); subscription.getClient().getCtx().writeAndFlush(msg); } } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttMessageSender.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import io.netty.handler.codec.mqtt.MqttPublishMessage; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; public class MqttMessageSender implements MessageHandler { /** * send the PUBLISH message to client * * @param message * @return whether the message is handled successfully */ @Override public void handleMessage(Message message) { MqttPublishMessage publishMessage = (MqttPublishMessage) message.getPayload(); message.getClient().getCtx().writeAndFlush(publishMessage); } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttPingreqMessageHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import io.netty.handler.codec.mqtt.MqttMessage; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; import org.apache.rocketmq.iot.common.util.MessageUtil; public class MqttPingreqMessageHandler implements MessageHandler { /** * handle the PINGREQ message from client *
    *
  1. check client exists
    2. *
  2. check client is connected
    3. *
  3. generate the PINGRESP message
    4. *
  4. send the PINGRESP message to the client
    5. *
* * @param message * @return */ @Override public void handleMessage(Message message) { Client client = message.getClient(); if (client == null || !client.isConnected()) { return ; } MqttMessage pingreqMessage = (MqttMessage) message.getPayload(); MqttMessage pingrespMessage = MessageUtil.getMqttPingrespMessage(pingreqMessage); client.getCtx().writeAndFlush(pingrespMessage); } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttPubackMessageHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import io.netty.handler.codec.mqtt.MqttPubAckMessage; import java.util.List; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; import org.apache.rocketmq.iot.storage.message.MessageStore; public class MqttPubackMessageHandler implements MessageHandler { private MessageStore messageStore; public MqttPubackMessageHandler(MessageStore messageStore) { this.messageStore = messageStore; } /** * handle the PUBACK message from the client *
    *
  1. remove the message from the published in-flight messages
    2. *
  2. ack the message in the MessageStore
    3. *
* @param * @return */ @Override public void handleMessage(Message message) { MqttPubAckMessage pubAckMessage = (MqttPubAckMessage) message.getPayload(); // TODO: remove the message from the published in-flight message messageStore.ack(message, (List) message.getClient()); } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttPubcompMessageHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; public class MqttPubcompMessageHandler implements MessageHandler { /** * handle the PUBCOMP message from the client * @param message * @return */ @Override public void handleMessage(Message message) { } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttPublishMessageHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import io.netty.handler.codec.mqtt.MqttMessage; import io.netty.handler.codec.mqtt.MqttPubAckMessage; import io.netty.handler.codec.mqtt.MqttPublishMessage; import io.netty.handler.codec.mqtt.MqttQoS; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; import org.apache.rocketmq.iot.storage.message.MessageStore; import org.apache.rocketmq.iot.common.util.MessageUtil; public class MqttPublishMessageHandler implements MessageHandler { private MessageStore messageStore; public MqttPublishMessageHandler(MessageStore messageStore) { this.messageStore = messageStore; } @Override public void handleMessage(Message message) { Client client = message.getClient(); MqttPublishMessage publishMessage = (MqttPublishMessage) message.getPayload(); messageStore.put(message); int qos = MessageUtil.actualQos(publishMessage.fixedHeader().qosLevel().value()); if (qos == MqttQoS.AT_LEAST_ONCE.value()) { MqttPubAckMessage pubAckMessage = MessageUtil.getMqttPubackMessage(publishMessage); client.getCtx().writeAndFlush(pubAckMessage); } else if (qos == MqttQoS.EXACTLY_ONCE.value()) { MqttMessage pubrecMessage = MessageUtil.getMqttPubrecMessage(publishMessage); client.getCtx().writeAndFlush(pubrecMessage); } } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttPubrecMessageHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; public class MqttPubrecMessageHandler implements MessageHandler { /** * handle the PUBREC message from the clinet * @param message * @return */ @Override public void handleMessage(Message message) { } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttPubrelMessageHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; public class MqttPubrelMessageHandler implements MessageHandler { /** * handle the PUBREL message from the client * @param message * @return */ @Override public void handleMessage(Message message) { } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttSubscribeMessageHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import io.netty.handler.codec.mqtt.MqttSubAckMessage; import io.netty.handler.codec.mqtt.MqttSubAckPayload; import io.netty.handler.codec.mqtt.MqttSubscribeMessage; import io.netty.handler.codec.mqtt.MqttTopicSubscription; import java.util.ArrayList; import java.util.List; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.data.Subscription; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; import org.apache.rocketmq.iot.common.util.MessageUtil; public class MqttSubscribeMessageHandler implements MessageHandler { private SubscriptionStore subscriptionStore; public MqttSubscribeMessageHandler(SubscriptionStore subscriptionStore) { this.subscriptionStore = subscriptionStore; } /** * handle the SUBSCRIBE message from the client *
    *
  1. validate the topic filters in each subscription
    2. *
  2. set actual qos of each filter
    3. *
  3. get the topics matching given filters
    4. *
  4. check the client authorization of each topic
    5. *
  5. generate SUBACK message which includes the subscription result for each TopicFilter
    6. *
  6. send SUBACK message to the client
    7. *
* * @param message the message wrapping MqttSubscriptionMessage * @return */ @Override public void handleMessage(Message message) { Client client = message.getClient(); MqttSubscribeMessage subscribeMessage = (MqttSubscribeMessage) message.getPayload(); List topicSubscriptions = subscribeMessage.payload().topicSubscriptions(); List grantQoss = new ArrayList<>(); topicSubscriptions.forEach(s -> { String topic = s.topicName(); int actualQos = MessageUtil.actualQos(s.qualityOfService().value()); grantQoss.add(actualQos); subscriptionStore.append( topic, Subscription.Builder.newBuilder() .client((MqttClient) client) .qos(actualQos) .build() ); }); MqttSubAckMessage subackMessage = MessageUtil.getMqttSubackMessage(subscribeMessage, new MqttSubAckPayload(grantQoss)); client.getCtx().writeAndFlush(subackMessage); } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/impl/MqttUnsubscribeMessagHandler.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl; import io.netty.handler.codec.mqtt.MqttUnsubscribeMessage; import java.util.List; import java.util.Set; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.common.util.MessageUtil; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; /** * handle the UNSUBSCRIBE message from the client *
    *
  1. extract topic filters to be un-subscribed
    2. *
  2. get the topics matching with the topic filters
    3. *
  3. verify the authorization of the client to the
    4. *
  4. remove subscription from the SubscriptionStore
    5. *
*/ public class MqttUnsubscribeMessagHandler implements MessageHandler { private SubscriptionStore subscriptionStore; public MqttUnsubscribeMessagHandler(SubscriptionStore subscriptionStore) { this.subscriptionStore = subscriptionStore; } @Override public void handleMessage(Message message) { Client client = message.getClient(); MqttUnsubscribeMessage unsubscribeMessage = (MqttUnsubscribeMessage) message.getPayload(); List unsubscribeTopicFilters = unsubscribeMessage.payload().topics(); Set subscribedTopicFilters = subscriptionStore.getTopicFilters(client.getId()); for (String filter: unsubscribeTopicFilters) { if (subscribedTopicFilters.contains(filter)) { subscriptionStore.getTopics(filter).forEach(topic -> { subscriptionStore.remove(topic, client); }); } } client.getCtx().writeAndFlush(MessageUtil.getMqttUnsubackMessage(unsubscribeMessage)); } } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/storage/message/MessageStore.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.storage.message; import java.util.List; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; public interface MessageStore { /** * Get message from the topic by id, the method will return * null if the topic doesn't exist or the message doesn't exist * @param id identifier of the message * @return */ Message get(String id); /** * Put message to MessageStore * @param message the message to put to the Message Store * @return identidier of saved message */ String put(Message message); /** * Prepare to push message to the clients by marking the receiving id list of the clients * @param messageId the identifier of the message to be prepared * @param clientIds the identifier list of the clients which will receive the message * @param qos the QoS level of the message to be prepared */ void prepare(String messageId, List clientIds, int qos); /** * Acknowledge the message for the specific client * @param message the message to be acknowledged * @param client the client which acknowledge the message */ void ack(Message message, MqttClient client); /** * Acknowledge the message for the specific list of clients * @param message the message to be acknowledged * @param clients the list of clients which acknowledge the message */ void ack(Message message, List clients); /** * Expire the message with specific identifier * @param id identifier of the message to be expired */ void expire(String id); /** * Start the MessageStore */ void start(); /** * Get offline messages of the client * @param client * @return the offline messages of the client */ List getOfflineMessages(MqttClient client); /** * Shutdown the MessageStore */ void shutdown(); } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/storage/message/cache/MessageCache.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.storage.message.cache; import org.apache.rocketmq.iot.common.data.Message; public interface MessageCache { /** * get message by MessageId * @param topic the topic to which the message belongs * @param id the identifier of a message * @return the message whose id equals given id */ Message get(String topic, String id); /** * get latest message of the topic * @param topic * @return */ Message get(String topic); /** * put message with key MessageId * @param topic topic of the message, key of the storage pair * @param message actual message, value of the storage pair */ void put(String topic, Message message); /** * start the MessageCache */ void start(); /** * shutdown the MessageCache */ void shutdown(); } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/storage/subscription/SubscriptionStore.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.storage.subscription; import java.util.List; import java.util.Set; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.protocol.mqtt.data.Subscription; public interface SubscriptionStore { /** * Get the id list of the subscriptions which subscribe to the topic * @param topic * @return id list of the subscriptions which subscribe to the topic */ List get(String topic); /** * Check if a topic exists or not * @param topic * @return */ boolean hasTopic(String topic); /** * Add a new topic to existing subscriptions * @param topic the actual name topic instead of topicFilter */ void addTopic(String topic); /** * Append the client to the topic * @param topic the topic to which the client subscribes * @param subscription the subscription of the client * @return the subscription list of the client */ void append(String topic, Subscription subscription); /** * Remove the subscription of a client from the topic */ void remove(String topic, Client client); /** * Get the topics which match the filter * @param filter the topic filter which contains wildcards ('+' and '#') * @return matched topics */ List getTopics(String filter); /** * Get the topicFilters which are provided by the client when subscribed * @param clientId the identifier of the client * @return the topicFilters */ Set getTopicFilters(String clientId); /** * Start the Session Store */ void start(); /** * Shutdown the Session Store */ void shutdown(); } ================================================ FILE: rocketmq-iot-bridge/src/main/java/org/apache/rocketmq/iot/storage/subscription/impl/InMemorySubscriptionStore.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.storage.subscription.impl; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import java.util.HashSet; import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Collectors; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.protocol.mqtt.constant.MqttConstant; import org.apache.rocketmq.iot.protocol.mqtt.data.Subscription; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; public class InMemorySubscriptionStore implements SubscriptionStore { private ConcurrentHashMap> rootTopic2Topics = new ConcurrentHashMap<>(); private ConcurrentHashMap> topic2Subscriptions = new ConcurrentHashMap<>(); private Map> clientId2TopicFilters = new HashMap<>(); /** * get the id list of the clients which subscribe to the topic * * @param topic * @return id list of the clients which subscribe to the topic */ @Override public List get(String topic) { if (!topic2Subscriptions.containsKey(topic)) { return Collections.emptyList(); } return topic2Subscriptions.get(topic).stream().collect(Collectors.toList()); } /** * check if a topic exists or not * * @param topic * @return */ @Override public boolean hasTopic(String topic) { return topic2Subscriptions.containsKey(topic); } /** * add a new topic to existing subscriptions * * @param topic the actual name topic instead of topicFilter */ @Override public void addTopic(String topic) { if (topic2Subscriptions.containsKey(topic)) { return; } if (topic.contains(MqttConstant.SUBSCRIPTION_FLAG_PLUS) || topic.contains(MqttConstant.SUBSCRIPTION_FLAG_SHARP)) { return; } topic2Subscriptions.put(topic, new HashSet<>()); String rootTopic = getRootTopic(topic); if (!rootTopic2Topics.containsKey(rootTopic)) { rootTopic2Topics.put(rootTopic, new HashSet<>()); } rootTopic2Topics.get(rootTopic).add(topic); } /** * append the client to the topic * * @param topic * @param subscription * @return the subscription list of the client */ @Override public void append(String topic, Subscription subscription) { clientId2TopicFilters.putIfAbsent(subscription.getClient().getId(), new HashSet<>()); clientId2TopicFilters.get(subscription.getClient().getId()).add(topic); if (!topic.contains(MqttConstant.SUBSCRIPTION_FLAG_PLUS) && !topic.contains(MqttConstant.SUBSCRIPTION_FLAG_SHARP)) { String rootTopic = getRootTopic(topic); if (!topic2Subscriptions.containsKey(topic)) { addTopic(topic); } if (subscription == null) { return; } synchronized (this) { rootTopic2Topics.get(rootTopic).add(topic); topic2Subscriptions.get(topic).add(subscription); } } else { String rootTopic = getRootTopic(topic); if (rootTopic2Topics.containsKey(rootTopic)) { rootTopic2Topics.get(rootTopic) .stream() .filter(t -> match(topic, t)) .forEach(t -> append(t, subscription) ); } } } private String getRootTopic(String topic) { return topic.split(MqttConstant.SUBSCRIPTION_SEPARATOR)[0]; } /** * remote the client from the topic * * @param topic * @param client */ @Override public void remove(String topic, Client client) { if (topic2Subscriptions.containsKey(topic)) { Set subscriptions = topic2Subscriptions.get(topic); if (subscriptions == null) { return; } synchronized (subscriptions) { for (Iterator iter = subscriptions.iterator(); iter.hasNext(); ) { Subscription subscription = iter.next(); if (subscription.getClient().getId().equals(client.getId())) { iter.remove(); } } } } } /** * get the topics which match the filter * * @param filter@return matched topics */ @Override public List getTopics(String filter) { String rootTopic = getRootTopic(filter); if (!rootTopic2Topics.containsKey(rootTopic)) { return Collections.emptyList(); } return rootTopic2Topics.get(rootTopic).stream().filter(t -> match(filter, t)).collect(Collectors.toList()); } @Override public Set getTopicFilters(String clientId) { return clientId2TopicFilters.getOrDefault(clientId, Collections.emptySet()); } private boolean match(String filter, String topic) { if (!filter.contains(MqttConstant.SUBSCRIPTION_FLAG_PLUS) && !filter.contains(MqttConstant.SUBSCRIPTION_FLAG_SHARP)) { return filter.equals(topic); } String[] filterTopics = filter.split(MqttConstant.SUBSCRIPTION_SEPARATOR); String[] actualTopics = topic.split(MqttConstant.SUBSCRIPTION_SEPARATOR); int i = 0; for (; i < filterTopics.length && i < actualTopics.length; i++) { if (MqttConstant.SUBSCRIPTION_FLAG_PLUS.equals(filterTopics[i])) { continue; } if (MqttConstant.SUBSCRIPTION_FLAG_SHARP.equals(filterTopics[i])) { return true; } if (!filterTopics[i].equals(actualTopics[i])) { return false; } } return i == actualTopics.length; } /** * start the Session Store */ @Override public void start() { } /** * shutdown the Session Store */ @Override public void shutdown() { } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/connection/client/ClientManagerTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.connection.client; import io.netty.channel.Channel; import java.util.Map; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; import org.apache.commons.lang3.reflect.FieldUtils; import org.apache.rocketmq.iot.connection.client.impl.ClientManagerImpl; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; public class ClientManagerTest { private ClientManager clientManager; private Client client; private Channel channel; private Map channel2client; @Before public void setup() throws IllegalAccessException { clientManager = new ClientManagerImpl(); client = Mockito.mock(Client.class); channel = Mockito.mock(Channel.class); channel2client = (Map) FieldUtils.getDeclaredField(ClientManagerImpl.class, "channel2Client", true).get(clientManager); channel2client.put(channel, client); } @After public void teardown() { } @Test public void testGet() { /* Normal */ Assert.assertEquals(client, clientManager.get(channel)); /* Abnormal */ Channel fakeChannel = Mockito.mock(Channel.class); Assert.assertNull(clientManager.get(fakeChannel)); } @Test public void testPut() { Client newClient = Mockito.mock(Client.class); clientManager.put(channel, newClient); Assert.assertEquals(newClient, channel2client.get(channel)); Assert.assertNotEquals(client, channel2client.get(channel)); Channel anotherChannel = Mockito.mock(Channel.class); Client anotherClient = Mockito.mock(Client.class); clientManager.put(anotherChannel, anotherClient); Assert.assertEquals(anotherClient, clientManager.get(anotherChannel)); Channel channelWithNoClient = Mockito.mock(Channel.class); Assert.assertNull(clientManager.get(channelWithNoClient)); } @Test public void testRemove() { clientManager.remove(channel); Assert.assertNull(clientManager.get(channel)); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/integration/ConsumeMessageIntegrationTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.integration; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.embedded.EmbeddedChannel; import io.netty.handler.codec.mqtt.MqttConnAckMessage; import io.netty.handler.codec.mqtt.MqttConnectMessage; import io.netty.handler.codec.mqtt.MqttConnectPayload; import io.netty.handler.codec.mqtt.MqttConnectReturnCode; import io.netty.handler.codec.mqtt.MqttConnectVariableHeader; import io.netty.handler.codec.mqtt.MqttFixedHeader; import io.netty.handler.codec.mqtt.MqttMessageIdVariableHeader; import io.netty.handler.codec.mqtt.MqttMessageType; import io.netty.handler.codec.mqtt.MqttPublishMessage; import io.netty.handler.codec.mqtt.MqttPublishVariableHeader; import io.netty.handler.codec.mqtt.MqttQoS; import io.netty.handler.codec.mqtt.MqttSubAckMessage; import io.netty.handler.codec.mqtt.MqttSubscribeMessage; import io.netty.handler.codec.mqtt.MqttSubscribePayload; import io.netty.handler.codec.mqtt.MqttTopicSubscription; import java.util.ArrayList; import java.util.List; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.connection.client.impl.ClientManagerImpl; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.data.Subscription; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageDispatcher; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttConnectMessageHandler; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttMessageForwarder; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttSubscribeMessageHandler; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; import org.apache.rocketmq.iot.storage.subscription.impl.InMemorySubscriptionStore; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; public class ConsumeMessageIntegrationTest { private ClientManager clientManager; private SubscriptionStore subscriptionStore; private MessageDispatcher messageDispatcher; private MqttConnectMessageHandler mqttConnectMessageHandler; private MqttSubscribeMessageHandler mqttSubscribeMessageHandler; private MqttMessageForwarder mqttMessageForwarder; private EmbeddedChannel embeddedChannel; private MqttClient consuemr; private ChannelHandlerContext consuermCtx; private final String consumerId = "test-consumer-id"; private final String topicName = "test-topic"; private final int subscribePacketId = 1; private final int publishPakcetId = 2; private List subscriptions; @Before public void setup() { clientManager = new ClientManagerImpl(); subscriptionStore = new InMemorySubscriptionStore(); messageDispatcher = new MessageDispatcher(clientManager); mqttConnectMessageHandler = new MqttConnectMessageHandler(clientManager); mqttSubscribeMessageHandler = new MqttSubscribeMessageHandler(subscriptionStore); mqttMessageForwarder = new MqttMessageForwarder(subscriptionStore); messageDispatcher.registerHandler(Message.Type.MQTT_CONNECT, mqttConnectMessageHandler); messageDispatcher.registerHandler(Message.Type.MQTT_SUBSCRIBE, mqttSubscribeMessageHandler); messageDispatcher.registerHandler(Message.Type.MQTT_PUBLISH, mqttMessageForwarder); embeddedChannel = new EmbeddedChannel(messageDispatcher); subscriptions = new ArrayList<>(); subscriptions.add(new MqttTopicSubscription(topicName, MqttQoS.AT_MOST_ONCE)); consuemr = Mockito.spy(new MqttClient()); consuermCtx = Mockito.mock(ChannelHandlerContext.class); Mockito.when(consuemr.getCtx()).thenReturn(consuermCtx); } @After public void teardown() { } @Test public void test() { /* handle the CONNECT message */ MqttConnectMessage connectMessage = getConnectMessage(); embeddedChannel.writeInbound(connectMessage); MqttConnAckMessage connAckMessage = embeddedChannel.readOutbound(); Client client = clientManager.get(embeddedChannel); Assert.assertNotNull(client); Assert.assertTrue(consumerId.equals(client.getId())); Assert.assertEquals(consumerId, client.getId()); Assert.assertTrue(client.isConnected()); Assert.assertEquals(embeddedChannel, client.getCtx().channel()); Assert.assertTrue(client.isConnected()); Assert.assertTrue(embeddedChannel.isOpen()); Assert.assertEquals(MqttConnectReturnCode.CONNECTION_ACCEPTED, connAckMessage.variableHeader().connectReturnCode()); embeddedChannel.releaseInbound(); /* handle the SUBSCRIBE message */ MqttSubscribeMessage subscribeMessage = getMqttSubscribeMessage(); embeddedChannel.writeInbound(subscribeMessage); List subscriptions = subscriptionStore.get(topicName); List topics = subscriptionStore.getTopics(topicName); MqttSubAckMessage ackMessage = embeddedChannel.readOutbound(); Assert.assertNotNull(subscriptionStore.get(topicName)); Assert.assertNotNull(subscriptions); Assert.assertNotNull(ackMessage); Assert.assertEquals(subscribePacketId, ackMessage.variableHeader().messageId()); Assert.assertTrue(topics.contains(topicName)); Assert.assertTrue(isClientInSubscriptions(subscriptions, client)); embeddedChannel.releaseInbound(); /* send message to the client */ MqttPublishMessage publishMessage = getMqttPublishMessage(); byte [] expectedPayload = new byte[publishMessage.payload().readableBytes()]; publishMessage.payload().getBytes(0, expectedPayload); embeddedChannel.writeInbound(publishMessage); MqttPublishMessage receivedMessage = embeddedChannel.readOutbound(); byte [] actualPayload = new byte[receivedMessage.payload().readableBytes()]; receivedMessage.payload().getBytes(0, actualPayload); Assert.assertEquals(publishMessage.variableHeader().packetId(), receivedMessage.variableHeader().packetId()); Assert.assertEquals(publishMessage.variableHeader().topicName(), receivedMessage.variableHeader().topicName()); Assert.assertArrayEquals(expectedPayload, actualPayload); } private MqttConnectMessage getConnectMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.CONNECT, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttConnectVariableHeader variableHeader = new MqttConnectVariableHeader( "MQTT", 4, false, false, false, MqttQoS.AT_MOST_ONCE.value(), true, true, 60 ); MqttConnectPayload payload = new MqttConnectPayload( consumerId, "test-will-topic", "the test client is down".getBytes(), null, null ); return new MqttConnectMessage( fixedHeader, variableHeader, payload ); } private MqttPublishMessage getMqttPublishMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBLISH, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttPublishVariableHeader variableHeader = new MqttPublishVariableHeader( topicName, publishPakcetId ); return new MqttPublishMessage( fixedHeader, variableHeader, Unpooled.buffer().writeBytes("hello world".getBytes()) ); } private MqttSubscribeMessage getMqttSubscribeMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.SUBSCRIBE, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(subscribePacketId); MqttSubscribePayload payload = new MqttSubscribePayload( subscriptions ); return new MqttSubscribeMessage( fixedHeader, variableHeader, payload ); } private boolean isClientInSubscriptions(List subscriptions, Client client) { if (subscriptions == null || subscriptions.isEmpty()) { return false; } for (Subscription subscription: subscriptions) { if (subscription.getClient() == client) { return true; } } return false; } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/integration/ProduceMessageIntegrationTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.integration; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.embedded.EmbeddedChannel; import io.netty.handler.codec.mqtt.MqttConnAckMessage; import io.netty.handler.codec.mqtt.MqttConnectMessage; import io.netty.handler.codec.mqtt.MqttConnectPayload; import io.netty.handler.codec.mqtt.MqttConnectReturnCode; import io.netty.handler.codec.mqtt.MqttConnectVariableHeader; import io.netty.handler.codec.mqtt.MqttFixedHeader; import io.netty.handler.codec.mqtt.MqttMessage; import io.netty.handler.codec.mqtt.MqttMessageType; import io.netty.handler.codec.mqtt.MqttPublishMessage; import io.netty.handler.codec.mqtt.MqttPublishVariableHeader; import io.netty.handler.codec.mqtt.MqttQoS; import java.util.ArrayList; import java.util.List; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.connection.client.impl.ClientManagerImpl; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.data.Subscription; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageDispatcher; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttConnectMessageHandler; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttMessageForwarder; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; import org.apache.rocketmq.iot.storage.subscription.impl.InMemorySubscriptionStore; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; public class ProduceMessageIntegrationTest { private final String producerId = "test-client"; private final String topicName = "test-topic"; private final int packetId = 1; private EmbeddedChannel producerChannel; private MessageDispatcher dispatcher; private ClientManager clientManager; private SubscriptionStore subscriptionStore; private MqttConnectMessageHandler mqttConnectMessageHandler; private MqttMessageForwarder mqttMessageForwarder; private List mockedSubscriptions; private MqttClient mockedConsuemr; private ChannelHandlerContext mockedConsumerCtx; private EmbeddedChannel consumerChannel = new EmbeddedChannel(); @Before public void setup() { /* start the mocked MQTTBridge */ clientManager = new ClientManagerImpl(); subscriptionStore = Mockito.spy(new InMemorySubscriptionStore()); mqttConnectMessageHandler = new MqttConnectMessageHandler(clientManager); mqttMessageForwarder = new MqttMessageForwarder(subscriptionStore); dispatcher = new MessageDispatcher(clientManager); dispatcher.registerHandler(Message.Type.MQTT_CONNECT, mqttConnectMessageHandler); dispatcher.registerHandler(Message.Type.MQTT_PUBLISH, mqttMessageForwarder); producerChannel = new EmbeddedChannel(dispatcher); mockedConsuemr = Mockito.spy(new MqttClient()); mockedConsumerCtx = Mockito.mock(ChannelHandlerContext.class); mockedSubscriptions = new ArrayList<>(); mockedSubscriptions.add( Subscription.Builder.newBuilder() .client(mockedConsuemr) .qos(0) .build() ); Mockito.when(mockedConsuemr.getCtx()).thenReturn(mockedConsumerCtx); Mockito.when(mockedConsumerCtx.writeAndFlush(Mockito.any(MqttPublishMessage.class))).then(new Answer() { @Override public Object answer(InvocationOnMock mock) throws Throwable { MqttPublishMessage publishMessage = (MqttPublishMessage) mock.getArguments()[0]; consumerChannel.writeOutbound(publishMessage); return consumerChannel.newSucceededFuture(); } }); } @After public void teardown() { } @Test public void test() { /* handle the CONNECT message */ MqttConnectMessage connectMessage = getConnectMessage(); producerChannel.writeInbound(connectMessage); MqttConnAckMessage connAckMessage = producerChannel.readOutbound(); Client client = clientManager.get(producerChannel); Assert.assertNotNull(client); Assert.assertEquals(producerId, client.getId()); Assert.assertEquals(producerChannel, client.getCtx().channel()); Assert.assertTrue(client.isConnected()); Assert.assertTrue(producerChannel.isOpen()); Assert.assertEquals(MqttConnectReturnCode.CONNECTION_ACCEPTED, connAckMessage.variableHeader().connectReturnCode()); producerChannel.releaseInbound(); /* handle the PUBLISH message when there is no online Consumers */ MqttPublishMessage publishMessage = getMqttPublishMessage(); producerChannel.writeInbound(publishMessage); MqttMessage pubackMessage = producerChannel.readOutbound(); /* qos 0 should have no PUBACK message */ Assert.assertNull(pubackMessage); /* * the message would be discarded simply because there is no Consumers * and the topic should be created * */ Assert.assertTrue(subscriptionStore.hasTopic(topicName)); producerChannel.releaseInbound(); /* handle the PUBLISH message when there are online Consumers */ Mockito.when(subscriptionStore.get(topicName)).thenReturn(mockedSubscriptions); publishMessage = getMqttPublishMessage(); byte [] publishMessagePayload = new byte [publishMessage.payload().readableBytes()]; publishMessage.payload().getBytes(0, publishMessagePayload); producerChannel.writeInbound(publishMessage); MqttPublishMessage forwardedMessage = consumerChannel.readOutbound(); byte [] forwardedMessagePayload = new byte [forwardedMessage.payload().readableBytes()]; forwardedMessage.payload().getBytes(0, forwardedMessagePayload); Assert.assertNotNull(forwardedMessage); Assert.assertEquals(publishMessage.variableHeader().topicName(), forwardedMessage.variableHeader().topicName()); Assert.assertEquals(publishMessage.variableHeader().packetId(), forwardedMessage.variableHeader().packetId()); Assert.assertArrayEquals(publishMessagePayload, forwardedMessagePayload); } private MqttConnectMessage getConnectMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.CONNECT, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttConnectVariableHeader variableHeader = new MqttConnectVariableHeader( "MQTT", 4, false, false, false, MqttQoS.AT_MOST_ONCE.value(), true, true, 60 ); MqttConnectPayload payload = new MqttConnectPayload( producerId, "test-will-topic", "the test client is down".getBytes(), null, null ); return new MqttConnectMessage( fixedHeader, variableHeader, payload ); } private MqttPublishMessage getMqttPublishMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBLISH, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttPublishVariableHeader variableHeader = new MqttPublishVariableHeader( topicName, packetId ); return new MqttPublishMessage( fixedHeader, variableHeader, Unpooled.buffer().writeBytes("hello world".getBytes()) ); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/integration/PubSubIntegrationTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.integration; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.embedded.EmbeddedChannel; import io.netty.handler.codec.mqtt.MqttConnAckMessage; import io.netty.handler.codec.mqtt.MqttConnectMessage; import io.netty.handler.codec.mqtt.MqttConnectPayload; import io.netty.handler.codec.mqtt.MqttConnectReturnCode; import io.netty.handler.codec.mqtt.MqttConnectVariableHeader; import io.netty.handler.codec.mqtt.MqttFixedHeader; import io.netty.handler.codec.mqtt.MqttMessageIdVariableHeader; import io.netty.handler.codec.mqtt.MqttMessageType; import io.netty.handler.codec.mqtt.MqttPublishMessage; import io.netty.handler.codec.mqtt.MqttPublishVariableHeader; import io.netty.handler.codec.mqtt.MqttQoS; import io.netty.handler.codec.mqtt.MqttSubAckMessage; import io.netty.handler.codec.mqtt.MqttSubscribeMessage; import io.netty.handler.codec.mqtt.MqttSubscribePayload; import io.netty.handler.codec.mqtt.MqttTopicSubscription; import java.util.ArrayList; import java.util.List; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.connection.client.impl.ClientManagerImpl; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageDispatcher; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttConnectMessageHandler; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttMessageForwarder; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttSubscribeMessageHandler; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; import org.apache.rocketmq.iot.storage.subscription.impl.InMemorySubscriptionStore; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; public class PubSubIntegrationTest { private final String producerId = "test-producer-id"; private final String consumerId = "test-consumer-id"; private final String topicName = "test-topic"; private final int producerPublishId = 2; private final int consumerSubscribeId = 4; private ClientManager clientManager; private SubscriptionStore subscriptionStore; private MqttClient producer; private MqttClient consumer; private EmbeddedChannel producerChannel; private EmbeddedChannel consumerChannel; private MessageDispatcher messageDispatcher; private MqttConnectMessageHandler mqttConnectMessageHandler; private MqttMessageForwarder mqttMessageForwarder; private MqttSubscribeMessageHandler mqttSubscribeMessageHandler; private List topicSubscriptions = new ArrayList<>(); @Before public void setup() { clientManager = new ClientManagerImpl(); subscriptionStore = new InMemorySubscriptionStore(); messageDispatcher = new MessageDispatcher(clientManager); mqttConnectMessageHandler = new MqttConnectMessageHandler(clientManager); mqttSubscribeMessageHandler = new MqttSubscribeMessageHandler(subscriptionStore); mqttMessageForwarder = new MqttMessageForwarder(subscriptionStore); messageDispatcher.registerHandler(Message.Type.MQTT_CONNECT, mqttConnectMessageHandler); messageDispatcher.registerHandler(Message.Type.MQTT_PUBLISH, mqttMessageForwarder); messageDispatcher.registerHandler(Message.Type.MQTT_SUBSCRIBE, mqttSubscribeMessageHandler); producer = Mockito.spy(new MqttClient()); producer.setId(producerId); consumer = Mockito.spy(new MqttClient()); consumer.setId(consumerId); producerChannel = new EmbeddedChannel(messageDispatcher); producer.setCtx(producerChannel.pipeline().context("producer-ctx")); consumerChannel = new EmbeddedChannel(messageDispatcher); consumer.setCtx(consumerChannel.pipeline().context("consumer-ctx")); topicSubscriptions.add(new MqttTopicSubscription(topicName, MqttQoS.AT_MOST_ONCE)); // Mockito.when(consumerCtx.writeAndFlush(Mockito.any(MqttMessage.class))).then( // new Answer() { // @Override public Object answer(InvocationOnMock mock) throws Throwable { // MqttMessage message = (MqttMessage) mock.getArguments()[0]; // consumerChannel.writeOutbound(message); // return consumerChannel.newSucceededFuture(); // } // } // ); } @After public void teardown() { } @Test public void test() { /* the consumer connect and subscribe */ /* handle CONNECT message from consumer */ MqttConnectMessage consuemrConnectMessage = getConnectMessage(consumerId); consumerChannel.writeInbound(consuemrConnectMessage); MqttClient managedConsuemr = (MqttClient) clientManager.get(consumerChannel); MqttConnAckMessage consumerConnAckMessage = consumerChannel.readOutbound(); Assert.assertNotNull(managedConsuemr); Assert.assertEquals(consumerId, managedConsuemr.getId()); Assert.assertTrue(managedConsuemr.isConnected()); Assert.assertTrue(consumerChannel.isOpen()); Assert.assertEquals(consumerId, consuemrConnectMessage.payload().clientIdentifier()); Assert.assertEquals(MqttConnectReturnCode.CONNECTION_ACCEPTED, consumerConnAckMessage.variableHeader().connectReturnCode()); Assert.assertEquals(consuemrConnectMessage.variableHeader().isCleanSession(), consumerConnAckMessage.variableHeader().isSessionPresent()); consumerChannel.releaseInbound(); /* handle SUBSCRIBE message from consumer*/ MqttSubscribeMessage consumerSubscribeMessage = getMqttSubscribeMessage(); consumerChannel.writeInbound(consumerSubscribeMessage); MqttSubAckMessage consuemrSubAckMessage = consumerChannel.readOutbound(); Assert.assertNotNull(consuemrSubAckMessage); Assert.assertEquals(consumerSubscribeMessage.variableHeader().messageId(), consuemrSubAckMessage.variableHeader().messageId()); Assert.assertEquals(topicSubscriptions.size(), consuemrSubAckMessage.payload().grantedQoSLevels().size()); consumerChannel.releaseInbound(); /* the producer publish message to the topic */ /* handle CONNECT message from producer */ MqttConnectMessage producerConnectMessage = getConnectMessage(producerId); producerChannel.writeInbound(producerConnectMessage); MqttConnAckMessage producerConnAckMessage = producerChannel.readOutbound(); MqttClient managedProducer = (MqttClient) clientManager.get(producerChannel); Assert.assertNotNull(managedProducer); Assert.assertNotNull(producerConnAckMessage); Assert.assertTrue(managedProducer.isConnected()); Assert.assertTrue(producerChannel.isOpen()); Assert.assertEquals(producerId, managedProducer.getId()); Assert.assertEquals(MqttConnectReturnCode.CONNECTION_ACCEPTED, producerConnAckMessage.variableHeader().connectReturnCode()); Assert.assertEquals(producerConnectMessage.variableHeader().isCleanSession(), producerConnAckMessage.variableHeader().isSessionPresent()); producerChannel.releaseInbound(); /* handle PUBLISH message from producer */ MqttPublishMessage producerPublishMessage = getMqttPublishMessage(); byte [] expectedPayload = new byte[producerPublishMessage.payload().readableBytes()]; producerPublishMessage.payload().getBytes(0, expectedPayload); producerChannel.writeInbound(producerPublishMessage); MqttPublishMessage consumerReceivedMessage = consumerChannel.readOutbound(); byte [] actualPayload = new byte[consumerReceivedMessage.payload().readableBytes()]; consumerReceivedMessage.payload().getBytes(0, actualPayload); Assert.assertNotNull(consumerReceivedMessage); Assert.assertEquals(producerPublishMessage.variableHeader().packetId(), consumerReceivedMessage.variableHeader().packetId()); Assert.assertEquals(producerPublishMessage.variableHeader().topicName(), consumerReceivedMessage.variableHeader().topicName()); Assert.assertArrayEquals(expectedPayload, actualPayload); } private MqttConnectMessage getConnectMessage(String clientId) { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.CONNECT, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttConnectVariableHeader variableHeader = new MqttConnectVariableHeader( "MQTT", 4, false, false, false, MqttQoS.AT_MOST_ONCE.value(), true, true, 60 ); MqttConnectPayload payload = new MqttConnectPayload( clientId, "test-will-topic", "the test client is down".getBytes(), null, null ); return new MqttConnectMessage( fixedHeader, variableHeader, payload ); } private MqttPublishMessage getMqttPublishMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBLISH, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttPublishVariableHeader variableHeader = new MqttPublishVariableHeader( topicName, producerPublishId ); return new MqttPublishMessage( fixedHeader, variableHeader, Unpooled.buffer().writeBytes("hello world".getBytes()) ); } private MqttSubscribeMessage getMqttSubscribeMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.SUBSCRIBE, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(consumerSubscribeId); MqttSubscribePayload payload = new MqttSubscribePayload( topicSubscriptions ); return new MqttSubscribeMessage( fixedHeader, variableHeader, payload ); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/protocol/mqtt/handler/MqttConnectionHandlerTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler; import io.netty.channel.Channel; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.timeout.IdleStateEvent; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.event.DisconnectChannelEvent; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; public class MqttConnectionHandlerTest { private MqttConnectionHandler handler; private ClientManager clientManager; private SubscriptionStore subscriptionStore; private Client client; private Channel channel; private ChannelHandlerContext ctx; @Before public void setup() { clientManager = Mockito.mock(ClientManager.class); subscriptionStore = Mockito.mock(SubscriptionStore.class); handler = new MqttConnectionHandler(clientManager, subscriptionStore); client = Mockito.spy(new MqttClient()); channel = Mockito.mock(Channel.class); ctx = Mockito.mock(ChannelHandlerContext.class); Mockito.when( clientManager.get(channel) ).thenReturn(client); Mockito.when( ctx.channel() ).thenReturn(channel); } @After public void teardown() { } @Test public void testHandleDisconnectChannelEvent() throws Exception { DisconnectChannelEvent event = new DisconnectChannelEvent(channel); handler.userEventTriggered(ctx, event); Mockito.verify(clientManager).remove(channel); Mockito.verify(channel).close(); } @Test public void testHandleIdleStateEvent() throws Exception { IdleStateEvent idleStateEvent = IdleStateEvent.ALL_IDLE_STATE_EVENT; handler.userEventTriggered(ctx, idleStateEvent); Mockito.verify(clientManager, Mockito.times(1)).remove(channel); Mockito.verify(channel, Mockito.times(1)).close(); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/protocol/mqtt/handler/MqttDispatcherTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler; import io.netty.channel.embedded.EmbeddedChannel; import io.netty.handler.codec.mqtt.MqttConnectMessage; import java.util.Map; import org.apache.commons.lang3.reflect.FieldUtils; import org.apache.commons.lang3.reflect.MethodUtils; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.common.util.MessageUtil; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; public class MqttDispatcherTest { private MessageDispatcher messageDispatcher; private ClientManager clientManager; private MessageHandler mockedConnectMessageHandler; private MessageHandler mockedDisconnectMessageHandler; @Before public void setup() { clientManager = Mockito.mock(ClientManager.class); messageDispatcher = new MessageDispatcher(clientManager); mockedConnectMessageHandler = Mockito.mock(MessageHandler.class); mockedDisconnectMessageHandler = Mockito.mock(MessageHandler.class); } @After public void teardown() { } @Test public void testRegisterHandler() throws IllegalAccessException { messageDispatcher.registerHandler(Message.Type.MQTT_CONNECT, mockedConnectMessageHandler); messageDispatcher.registerHandler(Message.Type.MQTT_DISCONNECT, mockedDisconnectMessageHandler); Map type2handler = (Map) FieldUtils.getField(MessageDispatcher.class, "type2handler", true).get(messageDispatcher); Assert.assertEquals(mockedConnectMessageHandler, type2handler.get(Message.Type.MQTT_CONNECT)); Assert.assertEquals(mockedDisconnectMessageHandler, type2handler.get(Message.Type.MQTT_DISCONNECT)); } public void testChanelRead0 () { messageDispatcher.registerHandler(Message.Type.MQTT_CONNECT, mockedConnectMessageHandler); MqttConnectMessage mockedConnectMessage = Mockito.mock(MqttConnectMessage.class); Message mockedMessage = Mockito.spy(new Message()); Mockito.when(MessageUtil.getMessage(mockedConnectMessage)).thenReturn(mockedMessage); EmbeddedChannel embeddedChannel = new EmbeddedChannel(messageDispatcher); embeddedChannel.writeInbound(mockedConnectMessage); Mockito.verify(mockedConnectMessageHandler).handleMessage(mockedMessage); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/protocol/mqtt/handler/MqttIdleHandlerTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler; import io.netty.channel.Channel; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.DefaultEventLoop; import io.netty.channel.EventLoop; import io.netty.handler.timeout.IdleStateEvent; import java.util.concurrent.atomic.AtomicReference; import org.apache.commons.lang3.reflect.FieldUtils; import org.apache.rocketmq.iot.common.data.Message; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; public class MqttIdleHandlerTest { private ChannelHandlerContext ctx; private Channel channel; private MqttIdleHandler idleHandler; private AtomicReference state; private EventLoop loop; @Before public void setup() throws IllegalAccessException { idleHandler = new MqttIdleHandler(1); ctx = Mockito.mock(ChannelHandlerContext.class); // channel = Mockito.spy(new EmbeddedChannel()); // channel.attr(ChannelConfiguration.CHANNEL_IDLE_TIME_ATTRIBUTE_KEY).set(5); channel = Mockito.mock(Channel.class); state = (AtomicReference) FieldUtils.getField(MqttIdleHandler.class, "state", true).get(idleHandler); loop = new DefaultEventLoop(); Mockito.when(ctx.channel()).thenReturn(channel); Mockito.when(ctx.executor()).thenReturn(loop); Mockito.when(ctx.fireChannelRead(Mockito.any())).then(new Answer() { @Override public Object answer(InvocationOnMock mock) throws Throwable { return null; } }); Mockito.when(ctx.channel().isOpen()).thenReturn(true); Mockito.when(ctx.fireUserEventTriggered(Mockito.any(IdleStateEvent.class))).thenAnswer(new Answer() { @Override public Object answer(InvocationOnMock mock) throws Throwable { loop.shutdownGracefully(); return null; } }); } @After public void teardown() { } @Test public void test() throws Exception { Message message = new Message(); idleHandler.channelActive(ctx); idleHandler.channelRead(ctx, message); idleHandler.channelReadComplete(ctx); Thread.sleep(2000); // sleep for 2s Mockito.verify(ctx).fireUserEventTriggered(Mockito.any(IdleStateEvent.class)); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/AbstractMqttMessageHandlerTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import io.netty.channel.embedded.EmbeddedChannel; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; public abstract class AbstractMqttMessageHandlerTest { protected ClientManager clientManager; protected SubscriptionStore subscriptionStore; protected EmbeddedChannel embeddedChannel; protected Message message; protected MockHandler mockHandler; protected MessageHandler messageHandler; protected MqttClient client; class MockHandler extends SimpleChannelInboundHandler { private MessageHandler handler; MockHandler(MessageHandler handler) { this.handler = handler; } @Override protected void channelRead0(ChannelHandlerContext context, Message message) throws Exception { handler.handleMessage(message); } } /** * setup the message which will be handled by the mockHandler *
    *
  1. set message Type
    2. *
  2. set message Payload
    3. *
*/ public abstract void setupMessage(); /** * check the conditions after handle the message */ public abstract void assertConditions(); /** * mock the behaviors of the stubs */ public abstract void mock(); /** * init the message handler */ protected abstract void initMessageHandler(); @Test public void testHandleMessage() { embeddedChannel.writeInbound(message); assertConditions(); } @Before public void setup() { subscriptionStore = Mockito.mock(SubscriptionStore.class); clientManager = Mockito.mock(ClientManager.class); client = Mockito.spy(new MqttClient()); initMessageHandler(); mockHandler = new MockHandler(messageHandler); embeddedChannel = new EmbeddedChannel(mockHandler); initMessage(); mock(); Mockito.when(client.getCtx()).thenReturn( embeddedChannel.pipeline().context(mockHandler) ); } @After public void teardown() { } private void initMessage() { message = new Message(); setupMessage(); message.setClient(client); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/MqttConnectMessageHandlerTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream; import io.netty.channel.Channel; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandler; import io.netty.handler.codec.mqtt.MqttConnAckMessage; import io.netty.handler.codec.mqtt.MqttConnectMessage; import io.netty.handler.codec.mqtt.MqttConnectPayload; import io.netty.handler.codec.mqtt.MqttConnectReturnCode; import io.netty.handler.codec.mqtt.MqttConnectVariableHeader; import io.netty.handler.codec.mqtt.MqttFixedHeader; import io.netty.handler.codec.mqtt.MqttMessageType; import io.netty.handler.codec.mqtt.MqttQoS; import java.rmi.MarshalledObject; import junit.framework.TestFailure; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.protocol.mqtt.event.DisconnectChannelEvent; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttConnectMessageHandler; import org.junit.Assert; import org.mockito.Mock; import org.mockito.Mockito; public class MqttConnectMessageHandlerTest extends AbstractMqttMessageHandlerTest { private MqttConnectMessage connectMessage; private MqttConnAckMessage ackMessage; private ChannelInboundHandler mockedHandler; @Override public void setupMessage() { connectMessage = getConnectMessage(); message.setType(Message.Type.MQTT_CONNECT); message.setPayload(connectMessage); } @Override public void assertConditions() { } @Override public void mock() { mockedHandler = Mockito.mock(ChannelInboundHandler.class); embeddedChannel.pipeline().addLast("mocked-handler", mockedHandler); } @Override protected void initMessageHandler() { messageHandler = new MqttConnectMessageHandler(clientManager); } @Override public void testHandleMessage() { /* handle legal message*/ embeddedChannel.writeInbound(message); ackMessage = embeddedChannel.readOutbound(); Assert.assertEquals(MqttConnectReturnCode.CONNECTION_ACCEPTED, ackMessage.variableHeader().connectReturnCode()); Assert.assertTrue(embeddedChannel.isOpen()); /* handle CONNECT message when the client has been already connected */ embeddedChannel.writeInbound(message); Assert.assertNull(embeddedChannel.readOutbound()); try { Mockito.verify(mockedHandler).userEventTriggered(Mockito.any(ChannelHandlerContext.class), Mockito.any(DisconnectChannelEvent.class)); } catch (Exception e) { e.printStackTrace(); } } private MqttConnectMessage getConnectMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.CONNECT, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttConnectVariableHeader variableHeader = new MqttConnectVariableHeader( "MQTT", 4, false, false, false, MqttQoS.AT_MOST_ONCE.value(), true, true, 60 ); MqttConnectPayload payload = new MqttConnectPayload( "test-client", "test-will-topic", "the test client is down".getBytes(), null, null ); return new MqttConnectMessage( fixedHeader, variableHeader, payload ); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/MqttDisconnectMessageHandlerTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream; import io.netty.channel.Channel; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.mqtt.MqttFixedHeader; import io.netty.handler.codec.mqtt.MqttMessage; import io.netty.handler.codec.mqtt.MqttMessageType; import io.netty.handler.codec.mqtt.MqttQoS; import java.awt.color.CMMException; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttDisconnectMessageHandler; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; public class MqttDisconnectMessageHandlerTest extends AbstractMqttMessageHandlerTest { @Override public void setupMessage() { message.setType(Message.Type.MQTT_DISCONNECT); message.setPayload(getMqttDisconnectMessage()); } @Override public void assertConditions() { Mockito.verify(clientManager).remove(Mockito.any(Channel.class)); Assert.assertFalse(embeddedChannel.isOpen()); } @Override public void mock() { } @Override protected void initMessageHandler() { messageHandler = new MqttDisconnectMessageHandler(clientManager); } private MqttMessage getMqttDisconnectMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.DISCONNECT, false, MqttQoS.AT_MOST_ONCE, false, 0 ); return new MqttMessage(fixedHeader, null, null); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/MqttMessageForwarderTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.embedded.EmbeddedChannel; import io.netty.handler.codec.mqtt.MqttFixedHeader; import io.netty.handler.codec.mqtt.MqttMessageType; import io.netty.handler.codec.mqtt.MqttPublishMessage; import io.netty.handler.codec.mqtt.MqttPublishVariableHeader; import io.netty.handler.codec.mqtt.MqttQoS; import java.util.ArrayList; import java.util.Collections; import java.util.List; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.data.Subscription; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttMessageForwarder; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; public class MqttMessageForwarderTest extends AbstractMqttMessageHandlerTest { private MqttClient client1; private MqttClient client2; private EmbeddedChannel channel1; private EmbeddedChannel channel2; private Subscription subscription1; private Subscription subscription2; private List subscriptions; private String topicName = "test/forward/topic"; private int packetId = 1; private ByteBuf payload = Unpooled.wrappedBuffer("hello world".getBytes()); @Before public void setup() { client1 = Mockito.spy(new MqttClient()); channel1 = new EmbeddedChannel(); client1.setCtx(channel1.pipeline().lastContext()); client2 = Mockito.mock(MqttClient.class); channel2 = new EmbeddedChannel(); client2.setCtx(channel2.pipeline().lastContext()); subscription1 = Mockito.spy(Subscription.Builder.newBuilder().client(client1).build()); subscription2 = Mockito.spy(Subscription.Builder.newBuilder().client(client2).build()); subscriptions = new ArrayList<>(); subscriptions.add(subscription1); subscriptions.add(subscription2); } @After public void teardown() { } @Override public void setupMessage() { message.setType(Message.Type.MQTT_PUBLISH); message.setPayload(getMqttPublishMessage()); } @Override public void assertConditions() { MqttPublishMessage publishMessage1 = channel1.readOutbound(); Assert.assertEquals(packetId, publishMessage1.variableHeader().packetId()); Assert.assertEquals(topicName, publishMessage1.variableHeader().topicName()); byte [] exptectedPayload = new byte [payload.readableBytes()]; payload.getBytes(0, exptectedPayload); byte [] actualPayload1 = new byte [publishMessage1.payload().readableBytes()]; publishMessage1.payload().getBytes(0, actualPayload1); Assert.assertArrayEquals(exptectedPayload, actualPayload1); MqttPublishMessage publishMessage2 = channel2.readOutbound(); Assert.assertEquals(packetId, publishMessage2.variableHeader().packetId()); Assert.assertEquals(topicName, publishMessage2.variableHeader().topicName()); byte [] actualPayload2 = new byte [publishMessage1.payload().readableBytes()]; publishMessage1.payload().getBytes(0, actualPayload2); Assert.assertArrayEquals(exptectedPayload, actualPayload2); } @Override public void mock() { Mockito.when( subscriptionStore.get(Mockito.anyString()) ).thenReturn( subscriptions ); } @Override protected void initMessageHandler() { messageHandler = new MqttMessageForwarder(subscriptionStore); } @Test public void testHandleMessage() { } private MqttPublishMessage getMqttPublishMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBLISH, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttPublishVariableHeader variableHeader = new MqttPublishVariableHeader( topicName, packetId ); return new MqttPublishMessage( fixedHeader, variableHeader, payload ); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/MqttPingreqMessageHandlerTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.mqtt.MqttFixedHeader; import io.netty.handler.codec.mqtt.MqttMessage; import io.netty.handler.codec.mqtt.MqttMessageType; import io.netty.handler.codec.mqtt.MqttQoS; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.connection.client.Client; import org.apache.rocketmq.iot.connection.client.ClientManager; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttPingreqMessageHandler; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; public class MqttPingreqMessageHandlerTest { private ClientManager clientManager; private Client client; private ChannelHandlerContext ctx; private MqttPingreqMessageHandler handler; @Before public void setup() { clientManager = Mockito.mock(ClientManager.class); ctx = Mockito.mock(ChannelHandlerContext.class); client = Mockito.spy(new MqttClient()); client.setConnected(true); handler = new MqttPingreqMessageHandler(); Mockito.when( client.getCtx() ).thenReturn( ctx ); } @After public void teardown() { } @Test public void testHandleMessage() { Message message = new Message(); message.setClient(client); message.setPayload(getMqttPingreqMessage()); handler.handleMessage(message); Mockito.verify(ctx).writeAndFlush(Mockito.any(MqttMessage.class)); } private MqttMessage getMqttPingreqMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PINGREQ, false, MqttQoS.AT_MOST_ONCE, false, 0 ); return new MqttMessage( fixedHeader, null, null ); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/MqttSubscribeMessageHandlerTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import io.netty.channel.embedded.EmbeddedChannel; import io.netty.handler.codec.mqtt.MqttFixedHeader; import io.netty.handler.codec.mqtt.MqttMessageIdVariableHeader; import io.netty.handler.codec.mqtt.MqttMessageType; import io.netty.handler.codec.mqtt.MqttQoS; import io.netty.handler.codec.mqtt.MqttSubAckMessage; import io.netty.handler.codec.mqtt.MqttSubscribeMessage; import io.netty.handler.codec.mqtt.MqttSubscribePayload; import io.netty.handler.codec.mqtt.MqttTopicSubscription; import java.util.ArrayList; import java.util.List; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.handler.MessageHandler; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttSubscribeMessageHandler; import org.apache.rocketmq.iot.storage.subscription.SubscriptionStore; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; public class MqttSubscribeMessageHandlerTest extends AbstractMqttMessageHandlerTest { private MqttSubscribeMessage getMqttSubscribeMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.SUBSCRIBE, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(1); List subscriptions = new ArrayList<>(); subscriptions.add(new MqttTopicSubscription("topic1", MqttQoS.AT_MOST_ONCE)); subscriptions.add(new MqttTopicSubscription("topic2", MqttQoS.AT_LEAST_ONCE)); MqttSubscribePayload payload = new MqttSubscribePayload(subscriptions); return new MqttSubscribeMessage( fixedHeader, variableHeader, payload ); } @Override public void setupMessage() { message.setType(Message.Type.MQTT_SUBSCRIBE); message.setPayload(getMqttSubscribeMessage()); } @Override public void assertConditions() { MqttSubscribeMessage subscribeMessage = (MqttSubscribeMessage) this.message.getPayload(); MqttSubAckMessage ackMessage = embeddedChannel.readOutbound(); Assert.assertEquals(subscribeMessage.variableHeader().messageId(), ackMessage.variableHeader().messageId()); Assert.assertEquals(subscribeMessage.payload().topicSubscriptions().size(), ackMessage.payload().grantedQoSLevels().size()); } @Override public void mock() { } @Override protected void initMessageHandler() { messageHandler = new MqttSubscribeMessageHandler(subscriptionStore); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/protocol/mqtt/handler/downstream/MqttUnsubscribeMessageHandlerTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.protocol.mqtt.handler.downstream; import io.netty.handler.codec.mqtt.MqttFixedHeader; import io.netty.handler.codec.mqtt.MqttMessageIdVariableHeader; import io.netty.handler.codec.mqtt.MqttMessageType; import io.netty.handler.codec.mqtt.MqttQoS; import io.netty.handler.codec.mqtt.MqttUnsubAckMessage; import io.netty.handler.codec.mqtt.MqttUnsubscribeMessage; import io.netty.handler.codec.mqtt.MqttUnsubscribePayload; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; import org.apache.rocketmq.iot.common.data.Message; import org.apache.rocketmq.iot.protocol.mqtt.handler.downstream.impl.MqttUnsubscribeMessagHandler; import org.junit.Assert; import org.mockito.Mockito; public class MqttUnsubscribeMessageHandlerTest extends AbstractMqttMessageHandlerTest { private String topicFilter1 = "test/in/memory/+"; private String topicFilter2 = "test/in/disk/topic-c"; private String topicFilter3 = "test-topic-filter-3"; @Override public void setupMessage() { message.setType(Message.Type.MQTT_UNSUBSCRIBE); message.setPayload(getMqttUnsubscribeMessage()); } private MqttUnsubscribeMessage getMqttUnsubscribeMessage() { MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.UNSUBSCRIBE, false, MqttQoS.AT_MOST_ONCE, false, 0 ); MqttMessageIdVariableHeader variableHeader = MqttMessageIdVariableHeader.from(1); List topicFilters = new ArrayList<>(); MqttUnsubscribePayload payload = new MqttUnsubscribePayload(topicFilters); return new MqttUnsubscribeMessage( fixedHeader, variableHeader, payload ); } @Override public void assertConditions() { MqttUnsubscribeMessage unsubscribeMessage = (MqttUnsubscribeMessage) message.getPayload(); MqttUnsubAckMessage ackMessage = embeddedChannel.readOutbound(); Assert.assertEquals(unsubscribeMessage.variableHeader().messageId(), ackMessage.variableHeader().messageId()); } @Override public void mock() { Set mockedSubscribedTopicFiltersOfClient = new HashSet<>(); mockedSubscribedTopicFiltersOfClient.add(topicFilter1); mockedSubscribedTopicFiltersOfClient.add(topicFilter2); mockedSubscribedTopicFiltersOfClient.add(topicFilter3); client.setId("test-client-id"); Mockito.when( subscriptionStore.getTopicFilters( Mockito.anyString() ) ).thenReturn( mockedSubscribedTopicFiltersOfClient ); } @Override protected void initMessageHandler() { messageHandler = new MqttUnsubscribeMessagHandler(subscriptionStore); } } ================================================ FILE: rocketmq-iot-bridge/src/test/java/org/apache/rocketmq/iot/storage/subscription/InMemorySubscriptionTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.iot.storage.subscription; import org.apache.commons.lang3.reflect.FieldUtils; import org.apache.rocketmq.iot.protocol.mqtt.constant.MqttConstant; import org.apache.rocketmq.iot.protocol.mqtt.data.MqttClient; import org.apache.rocketmq.iot.protocol.mqtt.data.Subscription; import org.apache.rocketmq.iot.storage.subscription.impl.InMemorySubscriptionStore; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; import java.util.List; import java.util.Map; import java.util.Set; public class InMemorySubscriptionTest { private InMemorySubscriptionStore subscriptionStore = new InMemorySubscriptionStore(); private String topic1; private String topic2; private String topic3; private MqttClient client1; private MqttClient client2; private Subscription subscription1; private Subscription subscription2; private Map> rootTopic2Topics; @Before public void setup() throws IllegalAccessException { subscriptionStore = new InMemorySubscriptionStore(); topic1 = "test/in/memory/topic-a"; topic2 = "test/in/memory/topic-b"; topic3 = "test/in/disk/topic-c"; client1 = Mockito.spy(new MqttClient()); client2 = Mockito.spy(new MqttClient()); client1.setId("test-client-1"); client2.setId("test-client-2"); subscription1 = Subscription.Builder.newBuilder().client(client1).build(); subscription2 = Subscription.Builder.newBuilder().client(client2).build(); subscriptionStore.addTopic(topic1); subscriptionStore.addTopic(topic2); subscriptionStore.addTopic(topic3); } @Test public void testAppend() { /* test append with topicFilter without wildcard */ String topicFilter1 = "test/in/memory/topic-a"; // equals to topic1 subscriptionStore.append(topicFilter1, subscription1); subscriptionStore.append(topicFilter1, subscription2); List subscriptions1 = subscriptionStore.get(topic1); List subscriptions2 = subscriptionStore.get(topic2); List subscriptions3 = subscriptionStore.get(topic3); String rootTopic1 = topic1.split(MqttConstant.SUBSCRIPTION_SEPARATOR)[0]; Assert.assertTrue(inList(subscriptions1, subscription1)); Assert.assertTrue(inList(subscriptions1, subscription2)); Assert.assertFalse(inList(subscriptions2, subscription1)); Assert.assertFalse(inList(subscriptions2, subscription2)); Assert.assertFalse(inList(subscriptions3, subscription1)); Assert.assertFalse(inList(subscriptions3, subscription2)); subscriptionStore.remove(topic1, client1); subscriptionStore.remove(topic1, client2); /* test append with topicFilter with wildcard */ /* option 1: + wildcard */ String topicFilter2 = "test/in/memory/+"; subscriptionStore.append(topicFilter2, subscription1); subscriptionStore.append(topicFilter2, subscription2); subscriptions1 = subscriptionStore.get(topic1); subscriptions2 = subscriptionStore.get(topic2); subscriptions3 = subscriptionStore.get(topic3); Assert.assertTrue(inList(subscriptions1, subscription1)); Assert.assertTrue(inList(subscriptions1, subscription2)); Assert.assertTrue(inList(subscriptions2, subscription1)); Assert.assertTrue(inList(subscriptions2, subscription2)); Assert.assertFalse(inList(subscriptions3, subscription1)); Assert.assertFalse(inList(subscriptions3, subscription2)); subscriptionStore.remove(topic1, client1); subscriptionStore.remove(topic1, client2); subscriptionStore.remove(topic2, client1); subscriptionStore.remove(topic2, client2); /* option 2: # wildcard */ String topicFilter3 = "test/in/#"; subscriptionStore.append(topicFilter3, subscription1); subscriptionStore.append(topicFilter3, subscription2); subscriptions1 = subscriptionStore.get(topic1); subscriptions2 = subscriptionStore.get(topic2); subscriptions3 = subscriptionStore.get(topic3); Assert.assertTrue(inList(subscriptions1, subscription1)); Assert.assertTrue(inList(subscriptions1, subscription2)); Assert.assertTrue(inList(subscriptions2, subscription1)); Assert.assertTrue(inList(subscriptions2, subscription2)); Assert.assertTrue(inList(subscriptions3, subscription1)); Assert.assertTrue(inList(subscriptions3, subscription2)); subscriptionStore.remove(topic1, client1); subscriptionStore.remove(topic1, client2); subscriptionStore.remove(topic2, client1); subscriptionStore.remove(topic2, client2); subscriptionStore.remove(topic2, client1); subscriptionStore.remove(topic2, client2); /* test re-append */ subscriptionStore.append(topic1, subscription1); subscriptionStore.append(topic1, subscription1); subscriptionStore.append(topic1, subscription1); subscriptions1 = subscriptionStore.get(topic1); Assert.assertTrue(inList(subscriptions1, subscription1)); /* re-append should not include multiple subscription for same client of same topic */ Assert.assertTrue(subscriptions1.size() == 1); } @Test public void testRemove() { subscriptionStore.append(topic1, subscription1); subscriptionStore.append(topic1, subscription2); subscriptionStore.append(topic2, subscription1); subscriptionStore.append(topic2, subscription2); subscriptionStore.remove(topic1, client1); Assert.assertTrue(!inList(subscriptionStore.get(topic1), subscription1)); Assert.assertTrue(inList(subscriptionStore.get(topic1), subscription2)); Assert.assertTrue(!subscriptionStore.get(topic1).isEmpty()); Assert.assertTrue(inList(subscriptionStore.get(topic2), subscription1)); Assert.assertTrue(inList(subscriptionStore.get(topic2), subscription2)); Assert.assertTrue(!subscriptionStore.get(topic2).isEmpty()); subscriptionStore.remove(topic1, client2); Assert.assertTrue(!inList(subscriptionStore.get(topic1), subscription1)); Assert.assertTrue(!inList(subscriptionStore.get(topic1), subscription2)); Assert.assertTrue(subscriptionStore.get(topic1).isEmpty()); Assert.assertTrue(inList(subscriptionStore.get(topic2), subscription1)); Assert.assertTrue(inList(subscriptionStore.get(topic2), subscription2)); Assert.assertTrue(!subscriptionStore.get(topic2).isEmpty()); subscriptionStore.remove(topic2, client1); Assert.assertTrue(!inList(subscriptionStore.get(topic1), subscription1)); Assert.assertTrue(!inList(subscriptionStore.get(topic1), subscription2)); Assert.assertTrue(subscriptionStore.get(topic1).isEmpty()); Assert.assertTrue(!inList(subscriptionStore.get(topic2), subscription1)); Assert.assertTrue(inList(subscriptionStore.get(topic2), subscription2)); Assert.assertTrue(!subscriptionStore.get(topic2).isEmpty()); subscriptionStore.remove(topic2, client2); Assert.assertTrue(!inList(subscriptionStore.get(topic1), subscription1)); Assert.assertTrue(!inList(subscriptionStore.get(topic1), subscription2)); Assert.assertTrue(subscriptionStore.get(topic1).isEmpty()); Assert.assertTrue(!inList(subscriptionStore.get(topic2), subscription1)); Assert.assertTrue(!inList(subscriptionStore.get(topic2), subscription2)); Assert.assertTrue(subscriptionStore.get(topic1).isEmpty()); } @Test public void testAddTopic() throws IllegalAccessException { String topic = "test-topic"; String topicFilter = "test/filter/+"; subscriptionStore.addTopic(topic); subscriptionStore.addTopic(topicFilter); Map> topic2Subscriptions = (Map>) FieldUtils.getField(InMemorySubscriptionStore.class, "topic2Subscriptions", true).get(subscriptionStore); Assert.assertTrue(topic2Subscriptions.containsKey(topic)); /* topicFilter should be ignored */ Assert.assertFalse(topic2Subscriptions.containsKey(topicFilter)); } private boolean inList(List actualLsit, E expected) { if (actualLsit == null) return false; for (E actual: actualLsit) { if (actual == expected) { return true; } } return false; } } ================================================ FILE: rocketmq-iot-bridge/style/copyright/Apache.xml ================================================ ================================================ FILE: rocketmq-iot-bridge/style/copyright/profiles_settings.xml ================================================ ================================================ FILE: rocketmq-iot-bridge/style/rmq_checkstyle.xml ================================================ ================================================ FILE: rocketmq-iot-bridge/style/rmq_codeStyle.xml ================================================ ================================================ FILE: rocketmq-jms/.gitignore ================================================ .idea/ *.iml *.ipr *.iws target/ ================================================ FILE: rocketmq-jms/.travis.yml ================================================ notifications: email: recipients: - zhangke.huangshan@gmail.com - zhendongliu92@gmail.com on_success: change on_failure: always language: java matrix: include: # On OSX, run with default JDK only. # - os: osx # On Linux, run with specific JDKs only. # - os: linux # env: CUSTOM_JDK="oraclejdk8" - os: linux env: CUSTOM_JDK="oraclejdk7" #- os: linux # env: CUSTOM_JDK="openjdk7" before_install: - echo 'MAVEN_OPTS="$MAVEN_OPTS -Xmx1024m -XX:MaxPermSize=512m -XX:+BytecodeVerificationLocal"' >> ~/.mavenrc - cat ~/.mavenrc - if [ "$TRAVIS_OS_NAME" == "osx" ]; then export JAVA_HOME=$(/usr/libexec/java_home); fi - if [ "$TRAVIS_OS_NAME" == "linux" ]; then jdk_switcher use "$CUSTOM_JDK"; fi #os: # - linux # - osx #jdk: # - oraclejdk8 # - oraclejdk7 # - openjdk7 script: - travis_retry mvn -B clean install jacoco:report coveralls:report #after_success: # - mvn clean install # - mvn sonar:sonar ================================================ FILE: rocketmq-jms/README.md ================================================ # RocketMQ-JMS ## Introduction RocketMQ-JMS is an implement of JMS specification,taking Apache RocketMQ as broker. Now we are on the way of supporting JMS 1.1 and JMS2.0 is our final target. ## Building > cd rocketmq-jms > mvn clean install **run unit test:** > mvn test **run integration test:** > mvn verify **see jacoco code coverage report** > open core/target/site/jacoco/index.html > open core/target/site/jacoco-it/index.html > open spring/target/site/jacoco-it/index.html ## Guidelines Please see [Coding Guidelines Introduction](http://rocketmq.apache.org/docs/code-guidelines/) ================================================ FILE: rocketmq-jms/core/pom.xml ================================================ rocketmq-jms-all org.apache.rocketmq 1.0-SNAPSHOT 4.0.0 rocketmq-jms 1.0-SNAPSHOT org.apache.maven.plugins maven-jar-plugin test-jar ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/CommonConstant.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain; public interface CommonConstant { String PRODUCERID = "producerId"; String CONSUMERID = "consumerId"; String PROVIDER = "provider"; String NAMESERVER = "nameServer"; String INSTANCE_NAME = "instanceName"; String CONSUME_THREAD_NUMS = "consumeThreadNums"; String SEND_TIMEOUT_MILLIS = "sendMsgTimeoutMillis"; } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/CommonContext.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain; import org.apache.commons.lang.builder.ReflectionToStringBuilder; import org.apache.commons.lang.builder.ToStringStyle; public class CommonContext { private String accessKey; private String secretKey; private String consumerId; private String producerId; private String provider; private String appId; private String nameServer; /** * MQType */ private String mqType; /** * Using for distinguishing client jvm process */ private String instanceName; /** * Set consumer threadPool Size */ private int consumeThreadNums; /** * Set send message timeOut */ private int sendMsgTimeoutMillis = -1; /** * @return the appId */ public String getAppId() { return appId; } /** * @param appId the appId to set */ public void setAppId(String appId) { this.appId = appId; } /** * @return the provider */ public String getProvider() { return provider; } /** * @param provider the provider to set */ public void setProvider(String provider) { this.provider = provider; } /** * @return the instanceName */ public String getInstanceName() { return instanceName; } /** * @param instanceName the instanceName to set */ public void setInstanceName(String instanceName) { this.instanceName = instanceName; } /** * @return the accessKey */ public String getAccessKey() { return accessKey; } /** * @param accessKey the accessKey to set */ public void setAccessKey(String accessKey) { this.accessKey = accessKey; } /** * @return the secretKey */ public String getSecretKey() { return secretKey; } /** * @param secretKey the secretKey to set */ public void setSecretKey(String secretKey) { this.secretKey = secretKey; } /** * @return consumer thread nums */ public int getConsumeThreadNums() { return consumeThreadNums; } /** * @param consumeThreadNums */ public void setConsumeThreadNums(int consumeThreadNums) { this.consumeThreadNums = consumeThreadNums; } public String getConsumerId() { return consumerId; } public void setConsumerId(String consumerId) { this.consumerId = consumerId; } public String getProducerId() { return producerId; } public void setProducerId(String producerId) { this.producerId = producerId; } public int getSendMsgTimeoutMillis() { return sendMsgTimeoutMillis; } public void setSendMsgTimeoutMillis(int sendMsgTimeoutMillis) { this.sendMsgTimeoutMillis = sendMsgTimeoutMillis; } public String getMqType() { return mqType; } public void setMqType(String mqType) { this.mqType = mqType; } public String getNameServer() { return nameServer; } public void setNameServer(String nameServer) { this.nameServer = nameServer; } @Override public String toString() { return ReflectionToStringBuilder.toString(this, ToStringStyle.DEFAULT_STYLE); } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/JmsBaseConnection.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain; import com.google.common.base.Preconditions; import java.util.Map; import java.util.UUID; import java.util.concurrent.atomic.AtomicBoolean; import javax.jms.Connection; import javax.jms.ConnectionConsumer; import javax.jms.ConnectionMetaData; import javax.jms.Destination; import javax.jms.ExceptionListener; import javax.jms.JMSException; import javax.jms.ServerSessionPool; import javax.jms.Session; import javax.jms.Topic; import org.apache.commons.lang.StringUtils; public class JmsBaseConnection implements Connection { private final AtomicBoolean started = new AtomicBoolean(false); protected String clientID; protected ExceptionListener exceptionListener; protected CommonContext context; protected JmsBaseSession session; public JmsBaseConnection(Map connectionParams) { this.clientID = UUID.randomUUID().toString(); context = new CommonContext(); //At lease one should be set context.setProducerId(connectionParams.get(CommonConstant.PRODUCERID)); context.setConsumerId(connectionParams.get(CommonConstant.CONSUMERID)); //optional context.setProvider(connectionParams.get(CommonConstant.PROVIDER)); String nameServer = connectionParams.get(CommonConstant.NAMESERVER); String consumerThreadNums = connectionParams.get(CommonConstant.CONSUME_THREAD_NUMS); String sendMsgTimeoutMillis = connectionParams.get(CommonConstant.SEND_TIMEOUT_MILLIS); String instanceName = connectionParams.get(CommonConstant.INSTANCE_NAME); if (StringUtils.isNotEmpty(nameServer)) { context.setNameServer(nameServer); } if (StringUtils.isNotEmpty(instanceName)) { context.setInstanceName(connectionParams.get(CommonConstant.INSTANCE_NAME)); } if (StringUtils.isNotEmpty(consumerThreadNums)) { context.setConsumeThreadNums(Integer.parseInt(consumerThreadNums)); } if (StringUtils.isNotEmpty(sendMsgTimeoutMillis)) { context.setSendMsgTimeoutMillis(Integer.parseInt(sendMsgTimeoutMillis)); } } @Override public Session createSession(boolean transacted, int acknowledgeMode) throws JMSException { Preconditions.checkArgument(!transacted, "Not support transaction Session !"); Preconditions.checkArgument(Session.AUTO_ACKNOWLEDGE == acknowledgeMode, "Not support this acknowledge mode: " + acknowledgeMode); if (null != this.session) { return this.session; } synchronized (this) { if (null != this.session) { return this.session; } this.session = new JmsBaseSession(this, transacted, acknowledgeMode, context); if (isStarted()) { this.session.start(); } return this.session; } } @Override public String getClientID() throws JMSException { return this.clientID; } @Override public void setClientID(String clientID) throws JMSException { this.clientID = clientID; } @Override public ConnectionMetaData getMetaData() throws JMSException { return new JmsBaseConnectionMetaData(); } @Override public ExceptionListener getExceptionListener() throws JMSException { return this.exceptionListener; } @Override public void setExceptionListener(ExceptionListener listener) throws JMSException { this.exceptionListener = listener; } @Override public void start() throws JMSException { if (started.compareAndSet(false, true)) { if (this.session != null) { this.session.start(); } } } @Override public void stop() throws JMSException { //Stop the connection before closing it. //Do nothing here. } @Override public void close() throws JMSException { if (started.compareAndSet(true, false)) { if (this.session != null) { this.session.close(); } } } @Override public ConnectionConsumer createConnectionConsumer(Destination destination, String messageSelector, ServerSessionPool sessionPool, int maxMessages) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public ConnectionConsumer createDurableConnectionConsumer(Topic topic, String subscriptionName, String messageSelector, ServerSessionPool sessionPool, int maxMessages) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } /** * Whether the connection is started. * * @return whether the connection is started. */ public boolean isStarted() { return started.get(); } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/JmsBaseConnectionFactory.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain; import com.google.common.base.Preconditions; import java.net.URI; import java.util.Map; import javax.jms.Connection; import javax.jms.ConnectionFactory; import javax.jms.JMSException; import org.apache.rocketmq.jms.util.URISpecParser; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class JmsBaseConnectionFactory implements ConnectionFactory { private static Logger logger = LoggerFactory .getLogger(JmsBaseConnectionFactory.class); /** * Synchronization monitor for the shared Connection */ private final Object connectionMonitor = new Object(); /** * Can be configured in a consistent way without too much URL hacking. */ protected URI connectionUri; /** * Store connection uri query parameters. */ protected Map connectionParams; /** * Wrapped Connection */ protected JmsBaseConnection connection; public JmsBaseConnectionFactory() { } public JmsBaseConnectionFactory(URI connectionUri) { setConnectionUri(connectionUri); } public void setConnectionUri(URI connectionUri) { Preconditions.checkNotNull(connectionUri, "Please set URI !"); this.connectionUri = connectionUri; this.connectionParams = URISpecParser.parseURI(connectionUri.toString()); if (null != connectionParams) { Preconditions.checkState(null != connectionParams.get(CommonConstant.CONSUMERID) || null != connectionParams.get(CommonConstant.PRODUCERID), "Please set consumerId or ProducerId !"); } } @Override public Connection createConnection() throws JMSException { synchronized (this.connectionMonitor) { if (this.connection == null) { initConnection(); } return this.connection; } } /** * Using userName and Password to create a connection * * @param userName ignored * @param password ignored * @return the new JMS Connection * @throws JMSException */ @Override public Connection createConnection(String userName, String password) throws JMSException { logger.debug("Using userName and Password to create a connection."); return this.createConnection(); } /** * Initialize the underlying shared Connection. *

* Closes and reInitializes the Connection if an underlying Connection is present already. * * @throws javax.jms.JMSException if thrown by JMS API methods */ protected void initConnection() throws JMSException { synchronized (this.connectionMonitor) { if (this.connection != null) { closeConnection(this.connection); } this.connection = doCreateConnection(); logger.debug("Established shared JMS Connection: {}", this.connection); } } /** * Close the given Connection. * * @param con the Connection to close */ protected void closeConnection(Connection con) { logger.debug("Closing shared JMS Connection: {}", this.connection); try { try { con.stop(); } finally { con.close(); } } catch (Throwable ex) { logger.error("Could not close shared JMS Connection.", ex); } } /** * Create a JMS Connection * * @return the new JMS Connection * @throws javax.jms.JMSException if thrown by JMS API methods */ protected JmsBaseConnection doCreateConnection() throws JMSException { Preconditions.checkState(null != this.connectionParams && this.connectionParams.size() > 0, "Connection Parameters can not be null!"); this.connection = new JmsBaseConnection(this.connectionParams); return connection; } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/JmsBaseConnectionMetaData.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain; import java.io.IOException; import java.io.InputStream; import java.util.Enumeration; import java.util.Properties; import java.util.Vector; import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.jms.ConnectionMetaData; import javax.jms.JMSException; public class JmsBaseConnectionMetaData implements ConnectionMetaData { public static final String JMS_VERSION; public static final int JMS_MAJOR_VERSION; public static final int JMS_MINOR_VERSION; public static final String PROVIDER_VERSION; public static final int PROVIDER_MAJOR_VERSION; public static final int PROVIDER_MINOR_VERSION; public static final String PROVIDER_NAME = "Apache RocketMQ"; public static final JmsBaseConnectionMetaData INSTANCE = new JmsBaseConnectionMetaData(); public static InputStream resourceStream; static { Pattern pattern = Pattern.compile("(\\d+)\\.(\\d+).*"); String jmsVersion = null; int jmsMajor = 0; int jmsMinor = 0; try { Package p = Package.getPackage("javax.jms"); if (p != null) { jmsVersion = p.getImplementationVersion(); Matcher m = pattern.matcher(jmsVersion); if (m.matches()) { jmsMajor = Integer.parseInt(m.group(1)); jmsMinor = Integer.parseInt(m.group(2)); } } } catch (Throwable e) { } JMS_VERSION = jmsVersion; JMS_MAJOR_VERSION = jmsMajor; JMS_MINOR_VERSION = jmsMinor; String providerVersion = null; int providerMajor = 0; int providerMinor = 0; Properties properties = new Properties(); try { resourceStream = JmsBaseConnectionMetaData.class.getResourceAsStream("/application.conf"); properties.load(resourceStream); providerVersion = properties.getProperty("version"); Matcher m = pattern.matcher(providerVersion); if (m.matches()) { providerMajor = Integer.parseInt(m.group(1)); providerMinor = Integer.parseInt(m.group(2)); } } catch (IOException e) { e.printStackTrace(); } PROVIDER_VERSION = providerVersion; PROVIDER_MAJOR_VERSION = providerMajor; PROVIDER_MINOR_VERSION = providerMinor; } public String getJMSVersion() throws JMSException { return JMS_VERSION; } public int getJMSMajorVersion() throws JMSException { return JMS_MAJOR_VERSION; } public int getJMSMinorVersion() throws JMSException { return JMS_MINOR_VERSION; } public String getJMSProviderName() throws JMSException { return PROVIDER_NAME; } public String getProviderVersion() throws JMSException { return PROVIDER_VERSION; } public int getProviderMajorVersion() throws JMSException { return PROVIDER_MAJOR_VERSION; } public int getProviderMinorVersion() throws JMSException { return PROVIDER_MINOR_VERSION; } public Enumeration getJMSXPropertyNames() throws JMSException { Vector jmxProperties = new Vector(); jmxProperties.add("jmsXUserId"); jmxProperties.add("jmsXAppId"); jmxProperties.add("jmsXGroupID"); jmxProperties.add("jmsXGroupSeq"); jmxProperties.add("jmsXState"); jmxProperties.add("jmsXDeliveryCount"); jmxProperties.add("jmsXProducerTXID"); jmxProperties.add("jmsConsumerTXID"); jmxProperties.add("jmsRecvTimeStamp"); return jmxProperties.elements(); } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/JmsBaseConstant.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain; public interface JmsBaseConstant { //------------------------JMS message header constant--------------------------------- String JMS_DESTINATION = "jmsDestination"; String JMS_DELIVERY_MODE = "jmsDeliveryMode"; String JMS_EXPIRATION = "jmsExpiration"; String JMS_DELIVERY_TIME = "jmsDeliveryTime"; String JMS_PRIORITY = "jmsPriority"; String JMS_MESSAGE_ID = "jmsMessageID"; String JMS_TIMESTAMP = "jmsTimestamp"; String JMS_CORRELATION_ID = "jmsCorrelationID"; String JMS_REPLY_TO = "jmsReplyTo"; String JMS_TYPE = "jmsType"; String JMS_REDELIVERED = "jmsRedelivered"; //-------------------------JMS defined properties constant---------------------------- /** * The identity of the user sending the Send message */ String JMS_XUSER_ID = "jmsXUserID"; /** * The identity of the application Send sending the message */ String JMS_XAPP_ID = "jmsXAppID"; /** * The number of message delivery Receive attempts */ String JMS_XDELIVERY_COUNT = "jmsXDeliveryCount"; /** * The identity of the message group this message is part of */ String JMS_XGROUP_ID = "jmsXGroupID"; /** * The sequence number of this message within the group; the first message is 1, the second 2,... */ String JMS_XGROUP_SEQ = "jmsXGroupSeq"; /** * The transaction identifier of the Send transaction within which this message was produced */ String JMS_XPRODUCER_TXID = "jmsXProducerTXID"; /** * The transaction identifier of the Receive transaction within which this message was consumed */ String JMS_XCONSUMER_TXID = "jmsXConsumerTXID"; /** * The time JMS delivered the Receive message to the consumer */ String JMS_XRCV_TIMESTAMP = "jmsXRcvTimestamp"; /** * Assume there exists a message warehouse that contains a separate copy of each message sent to each consumer and * that these copies exist from the time the original message was sent. Each copy’s state is one of: 1(waiting), * 2(ready), 3(expired) or 4(retained) Since state is of no interest to producers and consumers it is not provided * to either. It is only of relevance to messages looked up in a warehouse and JMS provides no API for this. */ String JMS_XSTATE = "jmsXState"; //---------------------------JMS Headers' value constant--------------------------- /** * Default time to live */ long DEFAULT_TIME_TO_LIVE = 3 * 24 * 60 * 60 * 1000; /** * Default Jms Type */ String DEFAULT_JMS_TYPE = "rocketmq"; } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/JmsBaseMessageConsumer.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain; import com.google.common.base.Preconditions; import com.google.common.base.Strings; import com.google.common.collect.MapMaker; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.atomic.AtomicBoolean; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.Message; import javax.jms.MessageConsumer; import javax.jms.MessageListener; import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.jms.util.ExceptionUtil; public class JmsBaseMessageConsumer implements MessageConsumer { private static final Object LOCK_OBJECT = new Object(); //all shared consumers private static ConcurrentMap consumerMap = new MapMaker().makeMap(); private final AtomicBoolean closed = new AtomicBoolean(false); private CommonContext context; private Destination destination; private MessageListener messageListener; public JmsBaseMessageConsumer(Destination destination, CommonContext commonContext, JmsBaseConnection connection) throws JMSException { synchronized (LOCK_OBJECT) { checkArgs(destination, commonContext); if (null == consumerMap.get(context.getConsumerId())) { DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(context.getConsumerId()); if (context.getConsumeThreadNums() > 0) { consumer.setConsumeThreadMax(context.getConsumeThreadNums()); consumer.setConsumeThreadMin(context.getConsumeThreadNums()); } if (!Strings.isNullOrEmpty(context.getNameServer())) { consumer.setNamesrvAddr(context.getNameServer()); } if (!Strings.isNullOrEmpty(context.getInstanceName())) { consumer.setInstanceName(context.getInstanceName()); } consumer.setConsumeMessageBatchMaxSize(1); //add subscribe? RMQPushConsumerExt rocketmqConsumerExt = new RMQPushConsumerExt(consumer); consumerMap.putIfAbsent(context.getConsumerId(), rocketmqConsumerExt); } consumerMap.get(context.getConsumerId()).incrementAndGet(); //If the connection has been started, start the consumer right now. //add start status? RMQPushConsumerExt consumerExt = consumerMap.get(context.getConsumerId()); if (connection.isStarted()) { try { consumerExt.start(); } catch (MQClientException mqe) { JMSException jmsException = new JMSException("Start consumer failed " + context.getConsumerId()); jmsException.initCause(mqe); throw jmsException; } } } } private void checkArgs(Destination destination, CommonContext context) throws JMSException { Preconditions.checkNotNull(context.getConsumerId(), "ConsumerId can not be null!"); Preconditions.checkNotNull(destination.toString(), "Destination can not be null!"); this.context = context; this.destination = destination; } @Override public String getMessageSelector() throws JMSException { return null; } @Override public MessageListener getMessageListener() throws JMSException { return this.messageListener; } @Override public void setMessageListener(MessageListener listener) throws JMSException { RMQPushConsumerExt rocketmqConsumerExt = consumerMap.get(context.getConsumerId()); if (null != rocketmqConsumerExt) { try { this.messageListener = listener; String messageTopic = ((JmsBaseTopic) destination).getMessageTopic(); String messageType = ((JmsBaseTopic) destination).getMessageType(); rocketmqConsumerExt.subscribe(messageTopic, messageType, listener); } catch (MQClientException mqe) { //add what? throw new JMSException(mqe.getMessage()); } } } @Override public Message receive() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } @Override public Message receive(long timeout) throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } @Override public Message receiveNoWait() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } @Override public void close() throws JMSException { synchronized (LOCK_OBJECT) { if (closed.compareAndSet(false, true)) { RMQPushConsumerExt rocketmqConsumerExt = consumerMap.get(context.getConsumerId()); if (null != rocketmqConsumerExt && 0 == rocketmqConsumerExt.decrementAndGet()) { rocketmqConsumerExt.close(); consumerMap.remove(context.getConsumerId()); } } } } /** * Start the consumer to get message from the Broker. */ public void startConsumer() throws JMSException { RMQPushConsumerExt rocketmqConsumerExt = consumerMap.get(context.getConsumerId()); if (null != rocketmqConsumerExt) { try { rocketmqConsumerExt.start(); } catch (MQClientException mqe) { throw ExceptionUtil.convertToJmsException(mqe, "Start consumer failed"); } } } public Destination getDestination() throws JMSException { return this.destination; } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/JmsBaseMessageProducer.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain; import com.google.common.base.Preconditions; import com.google.common.base.Strings; import com.google.common.collect.MapMaker; import java.util.Iterator; import java.util.Map; import java.util.Properties; import java.util.concurrent.ConcurrentMap; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.MessageProducer; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.client.producer.DefaultMQProducer; import org.apache.rocketmq.client.producer.MQProducer; import org.apache.rocketmq.client.producer.SendResult; import org.apache.rocketmq.client.producer.SendStatus; import org.apache.rocketmq.jms.domain.message.JmsBaseMessage; import org.apache.rocketmq.jms.domain.message.JmsBytesMessage; import org.apache.rocketmq.jms.domain.message.JmsObjectMessage; import org.apache.rocketmq.jms.domain.message.JmsTextMessage; import org.apache.rocketmq.jms.util.ExceptionUtil; import org.apache.rocketmq.jms.util.MessageConverter; import org.apache.rocketmq.jms.util.MsgConvertUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class JmsBaseMessageProducer implements MessageProducer { private static final Object LOCK_OBJECT = new Object(); private static ConcurrentMap producerMap = new MapMaker().makeMap(); private final Logger logger = LoggerFactory.getLogger(JmsBaseMessageProducer.class); private CommonContext context; private Destination destination; public JmsBaseMessageProducer(Destination destination, CommonContext context) throws JMSException { synchronized (LOCK_OBJECT) { checkArgs(destination, context); if (null == producerMap.get(this.context.getProducerId())) { DefaultMQProducer producer = new DefaultMQProducer(context.getProducerId()); if (!Strings.isNullOrEmpty(context.getNameServer())) { producer.setNamesrvAddr(context.getNameServer()); } if (!Strings.isNullOrEmpty(context.getInstanceName())) { producer.setInstanceName(context.getInstanceName()); } if (context.getSendMsgTimeoutMillis() > 0) { producer.setSendMsgTimeout(context.getSendMsgTimeoutMillis()); } try { producer.start(); } catch (MQClientException mqe) { throw ExceptionUtil.convertToJmsException(mqe, String.format("Start producer failed:%s", context.getProducerId())); } producerMap.putIfAbsent(this.context.getProducerId(), producer); } } } private void checkArgs(Destination destination, CommonContext context) throws JMSException { Preconditions.checkNotNull(context.getProducerId(), "ProducerId can not be null!"); Preconditions.checkNotNull(destination.toString(), "Destination can not be null!"); this.context = context; this.destination = destination; } @Override public boolean getDisableMessageID() throws JMSException { return false; } @Override public void setDisableMessageID(boolean value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } @Override public boolean getDisableMessageTimestamp() throws JMSException { return false; } @Override public void setDisableMessageTimestamp(boolean value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } @Override public int getDeliveryMode() throws JMSException { return javax.jms.Message.DEFAULT_DELIVERY_MODE; } @Override public void setDeliveryMode(int deliveryMode) throws JMSException { ExceptionUtil.handleUnSupportedException(); } @Override public int getPriority() throws JMSException { return javax.jms.Message.DEFAULT_PRIORITY; } @Override public void setPriority(int defaultPriority) throws JMSException { ExceptionUtil.handleUnSupportedException(); } @Override public long getTimeToLive() throws JMSException { return JmsBaseConstant.DEFAULT_TIME_TO_LIVE; } @Override public void setTimeToLive(long timeToLive) throws JMSException { ExceptionUtil.handleUnSupportedException(); } @Override public Destination getDestination() throws JMSException { return this.destination; } @Override public void close() throws JMSException { //Nothing to do } @Override public void send(javax.jms.Message message) throws JMSException { this.send(getDestination(), message); } /** * Send the message to the defined Destination success---return normally. Exception---throw out JMSException. * * @param destination see Destination * @param message the message to be sent. * @throws javax.jms.JMSException */ @Override public void send(Destination destination, javax.jms.Message message) throws JMSException { JmsBaseMessage jmsMsg = (JmsBaseMessage) message; initJMSHeaders(jmsMsg, destination); try { if (context == null) { throw new IllegalStateException("Context should be inited"); } org.apache.rocketmq.common.message.Message rocketmqMsg = MessageConverter.convert2RMQMessage(jmsMsg); MQProducer producer = producerMap.get(context.getProducerId()); if (producer == null) { throw new Exception("producer is null "); } SendResult sendResult = producer.send(rocketmqMsg); if (sendResult != null && sendResult.getSendStatus() == SendStatus.SEND_OK) { jmsMsg.setHeader(JmsBaseConstant.JMS_MESSAGE_ID, "ID:" + sendResult.getMsgId()); } else { throw new Exception("SendResult is " + (sendResult == null ? "null" : sendResult.toString())); } } catch (Exception e) { logger.error("Send rocketmq message failure !", e); //if fail to send the message, throw out JMSException JMSException jmsException = new JMSException("Send rocketmq message failure!"); jmsException.setLinkedException(e); throw jmsException; } } @Override public void send(javax.jms.Message message, int deliveryMode, int priority, long timeToLive) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public void send(Destination destination, javax.jms.Message message, int deliveryMode, int priority, long timeToLive) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } /** * Init the JmsMessage Headers. *

*

JMS providers init message's headers. Do not allow user to set these by yourself. * * @param jmsMsg message * @param destination * @throws javax.jms.JMSException * @see Destination */ private void initJMSHeaders(JmsBaseMessage jmsMsg, Destination destination) throws JMSException { //JMS_DESTINATION default:"topic:message" jmsMsg.setHeader(JmsBaseConstant.JMS_DESTINATION, destination); //JMS_DELIVERY_MODE default : PERSISTENT jmsMsg.setHeader(JmsBaseConstant.JMS_DELIVERY_MODE, javax.jms.Message.DEFAULT_DELIVERY_MODE); //JMS_TIMESTAMP default : current time jmsMsg.setHeader(JmsBaseConstant.JMS_TIMESTAMP, System.currentTimeMillis()); //JMS_EXPIRATION default : 3 days //JMS_EXPIRATION = currentTime + time_to_live jmsMsg.setHeader(JmsBaseConstant.JMS_EXPIRATION, System.currentTimeMillis() + JmsBaseConstant.DEFAULT_TIME_TO_LIVE); //JMS_PRIORITY default : 4 jmsMsg.setHeader(JmsBaseConstant.JMS_PRIORITY, javax.jms.Message.DEFAULT_PRIORITY); //JMS_TYPE default : open notification service jmsMsg.setHeader(JmsBaseConstant.JMS_TYPE, JmsBaseConstant.DEFAULT_JMS_TYPE); //JMS_REPLY_TO,JMS_CORRELATION_ID default : null //JMS_MESSAGE_ID is set by sendResult. //JMS_REDELIVERED is set by broker. } /** * Init the OnsMessage Headers. *

*

When converting JmsMessage to OnsMessage, should read from the JmsMessage's Properties and write to the * OnsMessage's Properties. * * @param jmsMsg message * @throws javax.jms.JMSException */ public static Properties initRocketMQHeaders(JmsBaseMessage jmsMsg, String topic, String messageType) throws JMSException { Properties userProperties = new Properties(); //Jms userProperties to properties Map userProps = jmsMsg.getProperties(); Iterator> userPropsIter = userProps.entrySet().iterator(); while (userPropsIter.hasNext()) { Map.Entry entry = userPropsIter.next(); userProperties.setProperty(entry.getKey(), entry.getValue().toString()); } //Jms systemProperties to ROCKETMQ properties Map sysProps = jmsMsg.getHeaders(); Iterator> sysPropsIter = sysProps.entrySet().iterator(); while (sysPropsIter.hasNext()) { Map.Entry entry = sysPropsIter.next(); userProperties.setProperty(entry.getKey(), entry.getValue().toString()); } //Jms message Model if (jmsMsg instanceof JmsBytesMessage) { userProperties.setProperty(MsgConvertUtil.JMS_MSGMODEL, MsgConvertUtil.MSGMODEL_BYTES); } else if (jmsMsg instanceof JmsObjectMessage) { userProperties.setProperty(MsgConvertUtil.JMS_MSGMODEL, MsgConvertUtil.MSGMODEL_OBJ); } else if (jmsMsg instanceof JmsTextMessage) { userProperties.setProperty(MsgConvertUtil.JMS_MSGMODEL, MsgConvertUtil.MSGMODEL_TEXT); } //message topic and tag userProperties.setProperty(MsgConvertUtil.MSG_TOPIC, topic); userProperties.setProperty(MsgConvertUtil.MSG_TYPE, messageType); return userProperties; } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/JmsBaseSession.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain; import com.google.common.base.Preconditions; import java.io.Serializable; import java.util.Arrays; import java.util.List; import java.util.UUID; import java.util.concurrent.CopyOnWriteArrayList; import javax.jms.BytesMessage; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.MapMessage; import javax.jms.Message; import javax.jms.MessageConsumer; import javax.jms.MessageListener; import javax.jms.MessageProducer; import javax.jms.ObjectMessage; import javax.jms.Queue; import javax.jms.QueueBrowser; import javax.jms.Session; import javax.jms.StreamMessage; import javax.jms.TemporaryQueue; import javax.jms.TemporaryTopic; import javax.jms.TextMessage; import javax.jms.Topic; import javax.jms.TopicSubscriber; import org.apache.rocketmq.jms.domain.message.JmsBytesMessage; import org.apache.rocketmq.jms.domain.message.JmsObjectMessage; import org.apache.rocketmq.jms.domain.message.JmsTextMessage; import org.apache.rocketmq.jms.util.ExceptionUtil; public class JmsBaseSession implements Session { protected CommonContext context; protected JmsBaseConnection connection; protected CopyOnWriteArrayList consumerList = new CopyOnWriteArrayList(); private boolean transacted = true; private int acknowledgeMode = AUTO_ACKNOWLEDGE; public JmsBaseSession(JmsBaseConnection connection, boolean transacted, int acknowledgeMode, CommonContext context) { this.context = context; this.acknowledgeMode = acknowledgeMode; this.transacted = transacted; this.connection = connection; } @Override public BytesMessage createBytesMessage() throws JMSException { return new JmsBytesMessage(); } @Override public MapMessage createMapMessage() throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public Message createMessage() throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public ObjectMessage createObjectMessage() throws JMSException { return new JmsObjectMessage(); } @Override public ObjectMessage createObjectMessage(Serializable object) throws JMSException { return new JmsObjectMessage(object); } @Override public StreamMessage createStreamMessage() throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public TextMessage createTextMessage() throws JMSException { return new JmsTextMessage(); } @Override public TextMessage createTextMessage(String text) throws JMSException { return new JmsTextMessage(text); } @Override public boolean getTransacted() throws JMSException { return this.transacted; } @Override public int getAcknowledgeMode() { return this.acknowledgeMode; } @Override public void commit() throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public void rollback() throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public void close() throws JMSException { for (JmsBaseMessageConsumer messageConsumer : consumerList) { messageConsumer.close(); } consumerList.clear(); } @Override public void recover() throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public MessageListener getMessageListener() throws JMSException { return null; } @Override public void setMessageListener(MessageListener listener) throws JMSException { ExceptionUtil.handleUnSupportedException(); } @Override public void run() { throw new UnsupportedOperationException("Unsupported"); } @Override public MessageProducer createProducer(Destination destination) throws JMSException { return new JmsBaseMessageProducer(destination, context); } /** * Create a MessageConsumer. *

*

Create a durable consumer to the specified destination * * @param destination Equals to Topic:MessageType in ROCKETMQ * @throws javax.jms.JMSException * @see Destination */ @Override public MessageConsumer createConsumer(Destination destination) throws JMSException { JmsBaseMessageConsumer messageConsumer = new JmsBaseMessageConsumer(destination, this.context, this.connection); this.consumerList.addIfAbsent(messageConsumer); return messageConsumer; } /** * Create a MessageConsumer with messageSelector. *

*

ROCKETMQ-JMS do not support using messageSelector to filter messages * * @param destination Equals to Topic:MessageType in ROCKETMQ * @param messageSelector For filtering messages * @throws javax.jms.JMSException * @see Destination */ @Override public MessageConsumer createConsumer(Destination destination, String messageSelector) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } /** * Create a MessageConsumer with messageSelector. *

*

ROCKETMQ-JMS do not support using messageSelector to filter messages and do not support this mechanism to reject * messages from localhost. * * @param destination Equals to Topic:MessageType in ROCKETMQ * @param messageSelector For filtering messages * @param noLocal If true: reject messages from localhost * @throws javax.jms.JMSException * @see Destination */ @Override public MessageConsumer createConsumer(Destination destination, String messageSelector, boolean noLocal) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public Queue createQueue(String queueName) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public Topic createTopic(String topicName) throws JMSException { Preconditions.checkNotNull(topicName); List msgTuple = Arrays.asList(topicName.split(":")); Preconditions.checkState(msgTuple.size() >= 1 && msgTuple.size() <= 2, "Destination must match messageTopic:messageType !"); //If messageType is null, use * instead. if (1 == msgTuple.size()) { return new JmsBaseTopic(msgTuple.get(0), "*"); } return new JmsBaseTopic(msgTuple.get(0), msgTuple.get(1)); } /** * Create a MessageConsumer with durable subscription. *

*

When using createConsumer(Destination) method, one creates a MessageConsumer with a durable * subscription. So use createConsumer(Destination) instead of these method. * * @param topic destination * @throws javax.jms.JMSException * @see Topic */ @Override public TopicSubscriber createDurableSubscriber(Topic topic, String name) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } /** * Create a MessageConsumer with durable subscription. *

*

When using createConsumer(Destination) method, one creates a MessageConsumer with a durable * subscription. So use createConsumer(Destination) instead of these method. * * @param topic destination * @throws javax.jms.JMSException * @see Topic */ @Override public TopicSubscriber createDurableSubscriber(Topic topic, String name, String messageSelector, boolean noLocal) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public QueueBrowser createBrowser(Queue queue) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public QueueBrowser createBrowser(Queue queue, String messageSelector) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } @Override public TemporaryQueue createTemporaryQueue() throws JMSException { return new TemporaryQueue() { public void delete() throws JMSException { } public String getQueueName() throws JMSException { return UUID.randomUUID().toString(); } }; } @Override public TemporaryTopic createTemporaryTopic() throws JMSException { return new TemporaryTopic() { public void delete() throws JMSException { } public String getTopicName() throws JMSException { return UUID.randomUUID().toString(); } }; } @Override public void unsubscribe(String name) throws JMSException { throw new UnsupportedOperationException("Unsupported"); } public void start() throws JMSException { for (JmsBaseMessageConsumer messageConsumer : consumerList) { messageConsumer.startConsumer(); } } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/JmsBaseTopic.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain; import com.google.common.base.Joiner; import com.google.common.base.Preconditions; import javax.jms.JMSException; import javax.jms.Topic; public class JmsBaseTopic implements Topic { private String messageTopic; private String messageType; public JmsBaseTopic(String messageTopic, String messageType) { Preconditions.checkNotNull(messageTopic); Preconditions.checkNotNull(messageType); this.messageTopic = messageTopic; this.messageType = messageType; } public String getTopicName() throws JMSException { return this.toString(); } public String toString() { return Joiner.on(":").join(this.getMessageTopic(), this.getMessageType()); } public String getMessageTopic() { return messageTopic; } public String getMessageType() { return messageType; } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/RMQPushConsumerExt.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain; import java.util.List; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicBoolean; import org.apache.rocketmq.client.consumer.MQPushConsumer; import java.util.concurrent.atomic.AtomicInteger; import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext; import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus; import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.common.message.MessageExt; import org.apache.rocketmq.jms.util.MessageConverter; public class RMQPushConsumerExt { private final MQPushConsumer consumer; private final ConcurrentHashMap subscribeTable = new ConcurrentHashMap(); private AtomicInteger referenceCount = new AtomicInteger(0); private AtomicBoolean started = new AtomicBoolean(false); public RMQPushConsumerExt(MQPushConsumer consumer) { this.consumer = consumer; } public MQPushConsumer getConsumer() { return consumer; } public int incrementAndGet() { return referenceCount.incrementAndGet(); } public int decrementAndGet() { return referenceCount.decrementAndGet(); } public int getReferenceCount() { return referenceCount.get(); } public void start() throws MQClientException { if (consumer == null) { throw new MQClientException(-1, "consumer is null"); } if (this.started.compareAndSet(false, true)) { this.consumer.registerMessageListener(new MessageListenerImpl()); this.consumer.start(); } } public void close() { if (this.started.compareAndSet(true, false)) { this.consumer.shutdown(); } } public void subscribe(String topic, String subExpression, javax.jms.MessageListener listener) throws MQClientException { if (null == topic) { throw new MQClientException(-1, "topic is null"); } if (null == listener) { throw new MQClientException(-1, "listener is null"); } try { this.subscribeTable.put(topic, listener); this.consumer.subscribe(topic, subExpression); } catch (MQClientException e) { throw new MQClientException("consumer subscribe exception", e); } } public void unsubscribe(String topic) { if (null != topic) { this.consumer.unsubscribe(topic); } } class MessageListenerImpl implements MessageListenerConcurrently { @Override public ConsumeConcurrentlyStatus consumeMessage(List msgsRMQList, ConsumeConcurrentlyContext contextRMQ) { MessageExt msgRMQ = msgsRMQList.get(0); javax.jms.MessageListener listener = RMQPushConsumerExt.this.subscribeTable.get(msgRMQ.getTopic()); if (null == listener) { throw new RuntimeException("MessageListener is null"); } try { listener.onMessage(MessageConverter.convert2JMSMessage(msgRMQ)); } catch (Exception e) { return ConsumeConcurrentlyStatus.RECONSUME_LATER; } return ConsumeConcurrentlyStatus.CONSUME_SUCCESS; } } public boolean isStarted() { return started.get(); } public boolean isClosed() { return !isStarted(); } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/message/JmsBaseMessage.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain.message; import com.google.common.collect.Maps; import com.google.common.io.BaseEncoding; import java.io.Serializable; import java.util.Enumeration; import java.util.Map; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.Message; import org.apache.commons.lang.builder.ToStringBuilder; import org.apache.rocketmq.jms.domain.JmsBaseConstant; import org.apache.rocketmq.jms.util.ExceptionUtil; public class JmsBaseMessage implements Message { /** * Message properties */ protected Map properties = Maps.newHashMap(); /** * Message headers */ protected Map headers = Maps.newHashMap(); /** * Message body */ protected Serializable body; @Override public String getJMSMessageID() { return (String) headers.get(JmsBaseConstant.JMS_MESSAGE_ID); } /** * Sets the message ID. *

*

JMS providers set this field when a message is sent. Do not allow User to set the message ID by yourself. * * @param id the ID of the message * @see javax.jms.Message#getJMSMessageID() */ @Override public void setJMSMessageID(String id) { ExceptionUtil.handleUnSupportedException(); } @Override public long getJMSTimestamp() { if (headers.containsKey(JmsBaseConstant.JMS_TIMESTAMP)) { return (Long) headers.get(JmsBaseConstant.JMS_TIMESTAMP); } return 0; } @Override public void setJMSTimestamp(long timestamp) { ExceptionUtil.handleUnSupportedException(); } @Override public byte[] getJMSCorrelationIDAsBytes() { String jmsCorrelationID = getJMSCorrelationID(); if (jmsCorrelationID != null) { try { return BaseEncoding.base64().decode(jmsCorrelationID); } catch (Exception e) { return jmsCorrelationID.getBytes(); } } return null; } @Override public void setJMSCorrelationIDAsBytes(byte[] correlationID) { String encodedText = BaseEncoding.base64().encode(correlationID); setJMSCorrelationID(encodedText); } @Override public String getJMSCorrelationID() { if (headers.containsKey(JmsBaseConstant.JMS_CORRELATION_ID)) { return (String) headers.get(JmsBaseConstant.JMS_CORRELATION_ID); } return null; } @Override public void setJMSCorrelationID(String correlationID) { ExceptionUtil.handleUnSupportedException(); } @Override public Destination getJMSReplyTo() { if (headers.containsKey(JmsBaseConstant.JMS_REPLY_TO)) { return (Destination) headers.get(JmsBaseConstant.JMS_REPLY_TO); } return null; } @Override public void setJMSReplyTo(Destination replyTo) { ExceptionUtil.handleUnSupportedException(); } @Override public String toString() { return ToStringBuilder.reflectionToString(this); } @Override public Destination getJMSDestination() { if (headers.containsKey(JmsBaseConstant.JMS_DESTINATION)) { return (Destination) headers.get(JmsBaseConstant.JMS_DESTINATION); } return null; } @Override public void setJMSDestination(Destination destination) { ExceptionUtil.handleUnSupportedException(); } @SuppressWarnings("unchecked") public T getBody(Class clazz) throws JMSException { if (clazz.isInstance(body)) { return (T) body; } else { throw new IllegalArgumentException("The class " + clazz + " is unknown to this implementation"); } } @Override public int getJMSDeliveryMode() { if (headers.containsKey(JmsBaseConstant.JMS_DELIVERY_MODE)) { return (Integer) headers.get(JmsBaseConstant.JMS_DELIVERY_MODE); } return 0; } /** * Sets the DeliveryMode value for this message. *

*

JMS providers set this field when a message is sent. ROCKETMQ only support DeliveryMode.PERSISTENT mode. So do not * allow User to set this by yourself, but you can get the default mode by getJMSDeliveryMode method. * * @param deliveryMode the delivery mode for this message * @see javax.jms.Message#getJMSDeliveryMode() * @see javax.jms.DeliveryMode */ @Override public void setJMSDeliveryMode(int deliveryMode) { ExceptionUtil.handleUnSupportedException(); } public boolean isBodyAssignableTo(Class clazz) throws JMSException { return clazz.isInstance(body); } @Override public boolean getJMSRedelivered() { return headers.containsKey(JmsBaseConstant.JMS_REDELIVERED) && (Boolean) headers.get(JmsBaseConstant.JMS_REDELIVERED); } @Override public void setJMSRedelivered(boolean redelivered) { ExceptionUtil.handleUnSupportedException(); } /** * copy meta data from source message * * @param sourceMessage source message */ public void copyMetaData(JmsBaseMessage sourceMessage) { if (!sourceMessage.getHeaders().isEmpty()) { for (Map.Entry entry : sourceMessage.getHeaders().entrySet()) { if (!exists(entry.getKey())) { setHeader(entry.getKey(), entry.getValue()); } } } if (!sourceMessage.getProperties().isEmpty()) { for (Map.Entry entry : sourceMessage.getProperties().entrySet()) { if (!propertyExists(entry.getKey())) { setObjectProperty(entry.getKey(), entry.getValue()); } } } } @Override public String getJMSType() { return (String) headers.get(JmsBaseConstant.JMS_TYPE); } @Override public void setJMSType(String type) { ExceptionUtil.handleUnSupportedException(); } public Map getHeaders() { return this.headers; } @Override public long getJMSExpiration() { if (headers.containsKey(JmsBaseConstant.JMS_EXPIRATION)) { return (Long) headers.get(JmsBaseConstant.JMS_EXPIRATION); } return 0; } @Override public void setJMSExpiration(long expiration) { ExceptionUtil.handleUnSupportedException(); } public boolean exists(String name) { return this.headers.containsKey(name); } @Override public int getJMSPriority() { if (headers.containsKey(JmsBaseConstant.JMS_PRIORITY)) { return (Integer) headers.get(JmsBaseConstant.JMS_PRIORITY); } return 5; } @Override public void setJMSPriority(int priority) { ExceptionUtil.handleUnSupportedException(); } public void setHeader(String name, Object value) { this.headers.put(name, value); } public Map getProperties() { return this.properties; } public void setProperties(Map properties) { this.properties = properties; } @Override public void acknowledge() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } @Override public void clearProperties() { this.properties.clear(); } @Override public void clearBody() { this.body = null; } @Override public boolean propertyExists(String name) { return properties.containsKey(name); } @Override public boolean getBooleanProperty(String name) throws JMSException { if (propertyExists(name)) { Object value = getObjectProperty(name); return value instanceof Boolean ? (Boolean) value : Boolean.valueOf(value.toString()); } return false; } @Override public byte getByteProperty(String name) throws JMSException { if (propertyExists(name)) { Object value = getObjectProperty(name); return value instanceof Byte ? (Byte) value : Byte.valueOf(value.toString()); } return 0; } @Override public short getShortProperty(String name) throws JMSException { if (propertyExists(name)) { Object value = getObjectProperty(name); return value instanceof Short ? (Short) value : Short.valueOf(value.toString()); } return 0; } @Override public int getIntProperty(String name) throws JMSException { if (propertyExists(name)) { Object value = getObjectProperty(name); return value instanceof Integer ? (Integer) value : Integer.valueOf(value.toString()); } return 0; } @Override public long getLongProperty(String name) throws JMSException { if (propertyExists(name)) { Object value = getObjectProperty(name); return value instanceof Long ? (Long) value : Long.valueOf(value.toString()); } return 0L; } @Override public float getFloatProperty(String name) throws JMSException { if (propertyExists(name)) { Object value = getObjectProperty(name); return value instanceof Float ? (Float) value : Float.valueOf(value.toString()); } return 0f; } @Override public double getDoubleProperty(String name) throws JMSException { if (propertyExists(name)) { Object value = getObjectProperty(name); return value instanceof Double ? (Double) value : Double.valueOf(value.toString()); } return 0d; } @Override public String getStringProperty(String name) throws JMSException { if (propertyExists(name)) { return getObjectProperty(name).toString(); } return null; } @Override public Object getObjectProperty(String name) throws JMSException { return this.properties.get(name); } @Override public Enumeration getPropertyNames() throws JMSException { final Object[] keys = this.properties.keySet().toArray(); return new Enumeration() { int i; @Override public boolean hasMoreElements() { return i < keys.length; } @Override public Object nextElement() { return keys[i++]; } }; } @Override public void setBooleanProperty(String name, boolean value) { setObjectProperty(name, value); } @Override public void setByteProperty(String name, byte value) { setObjectProperty(name, value); } @Override public void setShortProperty(String name, short value) { setObjectProperty(name, value); } @Override public void setIntProperty(String name, int value) { setObjectProperty(name, value); } @Override public void setLongProperty(String name, long value) { setObjectProperty(name, value); } public void setFloatProperty(String name, float value) { setObjectProperty(name, value); } @Override public void setDoubleProperty(String name, double value) { setObjectProperty(name, value); } @Override public void setStringProperty(String name, String value) { setObjectProperty(name, value); } @Override public void setObjectProperty(String name, Object value) { if (value instanceof Number || value instanceof String || value instanceof Boolean) { this.properties.put(name, value); } else { throw new IllegalArgumentException( "Value should be boolean, byte, short, int, long, float, double, and String."); } } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/message/JmsBytesMessage.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain.message; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.EOFException; import java.io.IOException; import javax.jms.BytesMessage; import javax.jms.JMSException; import javax.jms.MessageEOFException; import javax.jms.MessageFormatException; import javax.jms.MessageNotReadableException; import javax.jms.MessageNotWriteableException; import org.apache.rocketmq.jms.util.ExceptionUtil; /** * The BytesMessage methods are based largely on those found in java.io.DataInputStream and * java.io.DataOutputStream.

Notice:Although the JMS API allows the use of message properties with byte * messages, they are typically not used, since the inclusion of properties may affect the format.

*/ public class JmsBytesMessage extends JmsBaseMessage implements BytesMessage { private DataInputStream dataAsInput; private DataOutputStream dataAsOutput; private ByteArrayOutputStream bytesOut; private byte[] bytesIn; /** * Message created for reading * * @param data */ public JmsBytesMessage(byte[] data) { this.bytesIn = data; dataAsInput = new DataInputStream(new ByteArrayInputStream(data, 0, data.length)); } /** * Message created to be sent */ public JmsBytesMessage() { bytesOut = new ByteArrayOutputStream(); dataAsOutput = new DataOutputStream(bytesOut); } public long getBodyLength() throws JMSException { return getData().length; } /** * @return the data */ public byte[] getData() { if (bytesOut != null) { return bytesOut.toByteArray(); } else { return bytesIn; } } public boolean readBoolean() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } public byte readByte() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } public int readUnsignedByte() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } public short readShort() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } public int readUnsignedShort() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } public char readChar() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } public int readInt() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } public long readLong() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } public float readFloat() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } public double readDouble() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } public String readUTF() throws JMSException { throw new UnsupportedOperationException("Unsupported!"); } public int readBytes(byte[] value) throws JMSException { return readBytes(value, value.length); } public int readBytes(byte[] value, int length) throws JMSException { if (length > value.length) { throw new IndexOutOfBoundsException("length must be smaller than the length of value"); } if (dataAsInput == null) { throw new MessageNotReadableException("Message is not readable! "); } try { int offset = 0; while (offset < length) { int read = dataAsInput.read(value, offset, length - offset); if (read < 0) { break; } offset += read; } if (offset == 0 && length != 0) { return -1; } else { return offset; } } catch (IOException e) { throw handleInputException(e); } } public void writeBoolean(boolean value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } public void writeByte(byte value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } public void writeShort(short value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } public void writeChar(char value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } public void writeInt(int value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } public void writeLong(long value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } public void writeFloat(float value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } public void writeDouble(double value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } public void writeUTF(String value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } public void writeBytes(byte[] value) throws JMSException { if (dataAsOutput == null) { throw new MessageNotWriteableException("Message is not writable! "); } try { dataAsOutput.write(value); } catch (IOException e) { throw handleOutputException(e); } } public void writeBytes(byte[] value, int offset, int length) throws JMSException { if (dataAsOutput == null) { throw new MessageNotWriteableException("Message is not writable! "); } try { dataAsOutput.write(value, offset, length); } catch (IOException e) { throw handleOutputException(e); } } public void writeObject(Object value) throws JMSException { ExceptionUtil.handleUnSupportedException(); } public void reset() throws JMSException { ExceptionUtil.handleUnSupportedException(); } private JMSException handleOutputException(final IOException e) { JMSException ex = new JMSException(e.getMessage()); ex.initCause(e); ex.setLinkedException(e); return ex; } private JMSException handleInputException(final IOException e) { JMSException ex; if (e instanceof EOFException) { ex = new MessageEOFException(e.getMessage()); } else { ex = new MessageFormatException(e.getMessage()); } ex.initCause(e); ex.setLinkedException(e); return ex; } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/message/JmsObjectMessage.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain.message; import java.io.Serializable; import javax.jms.JMSException; import javax.jms.ObjectMessage; public class JmsObjectMessage extends JmsBaseMessage implements ObjectMessage { public JmsObjectMessage(Serializable object) { this.body = object; } public JmsObjectMessage() { } public Serializable getObject() throws JMSException { return this.body; } public void setObject(Serializable object) throws JMSException { this.body = object; } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/domain/message/JmsTextMessage.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain.message; import javax.jms.JMSException; import javax.jms.TextMessage; public class JmsTextMessage extends JmsBaseMessage implements TextMessage { private String text; public JmsTextMessage() { } public JmsTextMessage(String text) { setText(text); } public void clearBody() { this.text = null; super.clearBody(); } public String getText() throws JMSException { return this.text; } public void setText(String text) { this.body = text; this.text = text; } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/util/ExceptionUtil.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.util; import com.google.common.base.Preconditions; import javax.jms.JMSException; public class ExceptionUtil { public static final boolean SKIP_SET_EXCEPTION = Boolean.parseBoolean(System.getProperty("skip.set.exception", "false")); public static void handleUnSupportedException() { if (!ExceptionUtil.SKIP_SET_EXCEPTION) { throw new UnsupportedOperationException("Operation unsupported! If you want to skip this Exception," + " use '-Dskip.set.exception=true' in JVM options."); } } public static JMSException convertToJmsException(Exception e, String extra) { Preconditions.checkNotNull(extra); Preconditions.checkNotNull(e); JMSException jmsException = new JMSException(extra); jmsException.initCause(e); return jmsException; } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/util/MessageConverter.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.util; import org.apache.rocketmq.common.message.Message; import org.apache.rocketmq.common.message.MessageConst; import org.apache.rocketmq.common.message.MessageExt; import com.google.common.base.Charsets; import com.google.common.base.Preconditions; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Properties; import javax.jms.BytesMessage; import javax.jms.ObjectMessage; import javax.jms.TextMessage; import org.apache.commons.lang.StringUtils; import org.apache.rocketmq.jms.domain.JmsBaseConstant; import org.apache.rocketmq.jms.domain.JmsBaseTopic; import org.apache.rocketmq.jms.domain.message.JmsBaseMessage; import org.apache.rocketmq.jms.domain.message.JmsBytesMessage; import org.apache.rocketmq.jms.domain.message.JmsObjectMessage; import org.apache.rocketmq.jms.domain.message.JmsTextMessage; import static org.apache.rocketmq.jms.domain.JmsBaseMessageProducer.initRocketMQHeaders; public class MessageConverter { public static byte[] getContentFromJms(javax.jms.Message jmsMessage) throws Exception { byte[] content; if (jmsMessage instanceof TextMessage) { if (StringUtils.isEmpty(((TextMessage) jmsMessage).getText())) { throw new IllegalArgumentException("Message body length is zero"); } content = MsgConvertUtil.string2Bytes(((TextMessage) jmsMessage).getText(), Charsets.UTF_8.toString()); } else if (jmsMessage instanceof ObjectMessage) { if (((ObjectMessage) jmsMessage).getObject() == null) { throw new IllegalArgumentException("Message body length is zero"); } content = MsgConvertUtil.objectSerialize(((ObjectMessage) jmsMessage).getObject()); } else if (jmsMessage instanceof BytesMessage) { JmsBytesMessage bytesMessage = (JmsBytesMessage) jmsMessage; if (bytesMessage.getBodyLength() == 0) { throw new IllegalArgumentException("Message body length is zero"); } content = bytesMessage.getData(); } else { throw new IllegalArgumentException("Unknown message type " + jmsMessage.getJMSType()); } return content; } public static JmsBaseMessage convert2JMSMessage(MessageExt msg) throws Exception { JmsBaseMessage message; if (MsgConvertUtil.MSGMODEL_BYTES.equals( msg.getUserProperty(MsgConvertUtil.JMS_MSGMODEL))) { message = new JmsBytesMessage(msg.getBody()); } else if (MsgConvertUtil.MSGMODEL_OBJ.equals( msg.getUserProperty(MsgConvertUtil.JMS_MSGMODEL))) { message = new JmsObjectMessage(MsgConvertUtil.objectDeserialize(msg.getBody())); } else if (MsgConvertUtil.MSGMODEL_TEXT.equals( msg.getUserProperty(MsgConvertUtil.JMS_MSGMODEL))) { message = new JmsTextMessage(MsgConvertUtil.bytes2String(msg.getBody(), Charsets.UTF_8.toString())); } else { // rocketmq producer sends bytesMessage without setting JMS_MSGMODEL. message = new JmsBytesMessage(msg.getBody()); } //-------------------------set headers------------------------- Map properties = new HashMap(); message.setHeader(JmsBaseConstant.JMS_MESSAGE_ID, "ID:" + msg.getMsgId()); if (msg.getReconsumeTimes() > 0) { message.setHeader(JmsBaseConstant.JMS_REDELIVERED, Boolean.TRUE); } else { message.setHeader(JmsBaseConstant.JMS_REDELIVERED, Boolean.FALSE); } Map propertiesMap = msg.getProperties(); if (propertiesMap != null) { for (String properName : propertiesMap.keySet()) { String properValue = propertiesMap.get(properName); if (JmsBaseConstant.JMS_DESTINATION.equals(properName)) { String destinationStr = properValue; if (null != destinationStr) { List msgTuple = Arrays.asList(destinationStr.split(":")); message.setHeader(JmsBaseConstant.JMS_DESTINATION, new JmsBaseTopic(msgTuple.get(0), msgTuple.get(1))); } } else if (JmsBaseConstant.JMS_DELIVERY_MODE.equals(properName) || JmsBaseConstant.JMS_PRIORITY.equals(properName)) { message.setHeader(properName, properValue); } else if (JmsBaseConstant.JMS_TIMESTAMP.equals(properName) || JmsBaseConstant.JMS_EXPIRATION.equals(properName)) { message.setHeader(properName, properValue); } else if (JmsBaseConstant.JMS_CORRELATION_ID.equals(properName) || JmsBaseConstant.JMS_TYPE.equals(properName)) { message.setHeader(properName, properValue); } else if (JmsBaseConstant.JMS_MESSAGE_ID.equals(properName) || JmsBaseConstant.JMS_REDELIVERED.equals(properName)) { //JMS_MESSAGE_ID should set by msg.getMsgID() continue; } else { properties.put(properName, properValue); } } } //Handle System properties, put into header. //add what? message.setProperties(properties); return message; } public static Message convert2RMQMessage(JmsBaseMessage jmsMsg) throws Exception { Message rocketmqMsg = new MessageExt(); // 1. Transform message body rocketmqMsg.setBody(MessageConverter.getContentFromJms(jmsMsg)); // 2. Transform topic and messageType JmsBaseTopic destination = (JmsBaseTopic) jmsMsg.getHeaders().get(JmsBaseConstant.JMS_DESTINATION); String topic = destination.getMessageTopic(); rocketmqMsg.setTopic(topic); String messageType = destination.getMessageType(); Preconditions.checkState(!messageType.contains("||"), "'||' can not be in the destination when sending a message"); rocketmqMsg.setTags(messageType); // 3. Transform message properties Properties properties = initRocketMQHeaders(jmsMsg, topic, messageType); for (String name : properties.stringPropertyNames()) { String value = properties.getProperty(name); if (MessageConst.PROPERTY_KEYS.equals(name)) { rocketmqMsg.setKeys(value); } else if (MessageConst.PROPERTY_TAGS.equals(name)) { rocketmqMsg.setTags(value); } else if (MessageConst.PROPERTY_DELAY_TIME_LEVEL.equals(name)) { rocketmqMsg.setDelayTimeLevel(Integer.parseInt(value)); } else if (MessageConst.PROPERTY_WAIT_STORE_MSG_OK.equals(name)) { rocketmqMsg.setWaitStoreMsgOK(Boolean.parseBoolean(value)); } else if (MessageConst.PROPERTY_BUYER_ID.equals(name)) { rocketmqMsg.setBuyerId(value); } else { rocketmqMsg.putUserProperty(name, value); } } return rocketmqMsg; } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/util/MsgConvertUtil.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.util; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class MsgConvertUtil { public static final byte[] EMPTY_BYTES = new byte[0]; public static final String EMPTY_STRING = ""; public static final String JMS_MSGMODEL = "jmsMsgModel"; /** * To adapt this scene: "Notify client try to receive ObjectMessage sent by JMS client" Set notify out message * model, value can be textMessage OR objectMessage */ public static final String COMPATIBLE_FIELD_MSGMODEL = "notifyOutMsgModel"; public static final String MSGMODEL_TEXT = "textMessage"; public static final String MSGMODEL_BYTES = "bytesMessage"; public static final String MSGMODEL_OBJ = "objectMessage"; public static final String MSG_TOPIC = "msgTopic"; public static final String MSG_TYPE = "msgType"; public static byte[] objectSerialize(Object object) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(baos); oos.writeObject(object); oos.close(); baos.close(); return baos.toByteArray(); } public static Serializable objectDeserialize(byte[] bytes) throws IOException, ClassNotFoundException { ByteArrayInputStream bais = new ByteArrayInputStream(bytes); ObjectInputStream ois = new ObjectInputStream(bais); ois.close(); bais.close(); return (Serializable) ois.readObject(); } public static final byte[] string2Bytes(String s, String charset) { if (null == s) { return EMPTY_BYTES; } byte[] bs = null; try { bs = s.getBytes(charset); } catch (Exception e) { // ignore } return bs; } public static final String bytes2String(byte[] bs, String charset) { if (null == bs) { return EMPTY_STRING; } String s = null; try { s = new String(bs, charset); } catch (Exception e) { // ignore } return s; } } ================================================ FILE: rocketmq-jms/core/src/main/java/org/apache/rocketmq/jms/util/URISpecParser.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.util; import com.google.common.base.Preconditions; import com.google.common.collect.Maps; import java.util.Map; import org.apache.commons.lang.StringUtils; import org.apache.rocketmq.jms.domain.CommonConstant; public abstract class URISpecParser { private static final String DEFAULT_BROKER = "rocketmq"; /** * ConnectionUrl spec is broker://ip:port?key1=value1&key2=value2 * * @param uri Just like broker://ip:port?key1=value1&key2=value2 * @return The parameters' map */ public static Map parseURI(String uri) { Preconditions.checkArgument(null != uri && !uri.trim().isEmpty(), "Uri can not be empty!"); Map results = Maps.newHashMap(); String broker = uri.substring(0, uri.indexOf(":")); results.put(CommonConstant.PROVIDER, broker); if (broker.equals(DEFAULT_BROKER)) { //Special handle for alibaba inner mq broker String queryStr = uri.substring(uri.indexOf("?") + 1, uri.length()); if (StringUtils.isNotEmpty(queryStr)) { String[] params = queryStr.split("&"); for (String param : params) { if (param.contains("=")) { String[] values = param.split("=", 2); results.put(values[0], values[1]); } } } } else { throw new IllegalArgumentException("Broker must be rocketmq"); } return results; } } ================================================ FILE: rocketmq-jms/core/src/main/resources/application.conf ================================================ version = ${project.version} ================================================ FILE: rocketmq-jms/core/src/test/java/org/apache/rocketmq/jms/JmsTestListener.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms; import java.util.concurrent.CountDownLatch; import java.util.concurrent.atomic.AtomicInteger; import javax.jms.Message; import javax.jms.MessageListener; import org.junit.Assert; public class JmsTestListener implements MessageListener { private int expectd; private CountDownLatch latch; private AtomicInteger consumedNum = new AtomicInteger(0); public JmsTestListener() { this.expectd = 10; } public JmsTestListener(int expectd) { this.expectd = expectd; } public JmsTestListener(int expected, CountDownLatch latch) { this.expectd = expected; this.latch = latch; } @Override public void onMessage(Message message) { try { Assert.assertNotNull(message); Assert.assertNotNull(message.getJMSMessageID()); if (consumedNum.incrementAndGet() == expectd && latch != null) { latch.countDown(); } } catch (Exception e) { throw new RuntimeException(e); } } public int getConsumedNum() { return consumedNum.get(); } public void setLatch(CountDownLatch latch) { this.latch = latch; } public void setExpectd(int expectd) { this.expectd = expectd; } } ================================================ FILE: rocketmq-jms/core/src/test/java/org/apache/rocketmq/jms/JmsTestUtil.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms; import java.lang.reflect.Field; import java.util.concurrent.ConcurrentMap; import org.apache.rocketmq.client.producer.MQProducer; import org.apache.rocketmq.jms.domain.JmsBaseMessageConsumer; import org.apache.rocketmq.jms.domain.JmsBaseMessageProducer; import org.apache.rocketmq.jms.domain.RMQPushConsumerExt; import org.junit.Assert; public class JmsTestUtil { public static MQProducer getMQProducer(String producerId) throws Exception { Assert.assertNotNull(producerId); Field field = JmsBaseMessageProducer.class.getDeclaredField("producerMap"); field.setAccessible(true); ConcurrentMap producerMap = (ConcurrentMap) field.get(null); return producerMap.get(producerId); } public static RMQPushConsumerExt getRMQPushConsumerExt(String consumerId) throws Exception { Assert.assertNotNull(consumerId); Field field = JmsBaseMessageConsumer.class.getDeclaredField("consumerMap"); field.setAccessible(true); ConcurrentMap consumerMap = (ConcurrentMap) field.get(null); return consumerMap.get(consumerId); } public static void checkConsumerState(String consumerId, boolean isNull, boolean isStarted) throws Exception { RMQPushConsumerExt rmqPushConsumerExt = getRMQPushConsumerExt(consumerId); if (isNull) { Assert.assertNull(rmqPushConsumerExt); } else { Assert.assertNotNull(rmqPushConsumerExt); Assert.assertEquals(isStarted, rmqPushConsumerExt.isStarted()); } } } ================================================ FILE: rocketmq-jms/core/src/test/java/org/apache/rocketmq/jms/domain/message/JmsBytesMessageTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain.message; import org.junit.Assert; import org.junit.Test; public class JmsBytesMessageTest { private byte[] receiveData = "receive data test".getBytes(); private byte[] sendData = "send data test".getBytes(); @Test public void testGetData() throws Exception { JmsBytesMessage readMessage = new JmsBytesMessage(receiveData); System.out.println(new String(readMessage.getData())); Assert.assertEquals(new String(receiveData), new String(readMessage.getData())); JmsBytesMessage sendMessage = new JmsBytesMessage(); sendMessage.writeBytes(sendData, 0, sendData.length); System.out.println(new String(sendMessage.getData())); Assert.assertEquals(new String(sendData), new String(sendMessage.getData())); } @Test public void testGetBodyLength() throws Exception { JmsBytesMessage bytesMessage = new JmsBytesMessage(receiveData); System.out.println(bytesMessage.getBodyLength()); Assert.assertEquals(bytesMessage.getBodyLength(), receiveData.length); } @Test public void testReadBytes() throws Exception { JmsBytesMessage bytesMessage = new JmsBytesMessage(receiveData); Assert.assertEquals(bytesMessage.getBodyLength(), receiveData.length); byte[] receiveValue = new byte[receiveData.length]; bytesMessage.readBytes(receiveValue); System.out.println(new String(receiveValue)); Assert.assertEquals(new String(receiveValue), new String(receiveData)); } @Test public void testReadBytes1() throws Exception { JmsBytesMessage bytesMessage = new JmsBytesMessage(receiveData); byte[] receiveValue1 = new byte[2]; bytesMessage.readBytes(receiveValue1, 2); System.out.println(new String(receiveValue1)); Assert.assertEquals(new String(receiveData).substring(0, 2), new String(receiveValue1)); byte[] receiceValue2 = new byte[2]; bytesMessage.readBytes(receiceValue2, 2); System.out.println(new String(receiceValue2)); Assert.assertEquals(new String(receiveData).substring(2, 4), new String(receiceValue2)); } @Test public void testWriteBytes() throws Exception { JmsBytesMessage jmsBytesMessage = new JmsBytesMessage(); jmsBytesMessage.writeBytes(sendData); System.out.println(new String(jmsBytesMessage.getData())); Assert.assertEquals(new String(jmsBytesMessage.getData()), new String(sendData)); } @Test public void testException() throws Exception { JmsBytesMessage jmsBytesMessage = new JmsBytesMessage(); byte[] receiveValue = new byte[receiveData.length]; // Throws out NullPointerException // jmsBytesMessage.readBytes(receiveValue); JmsBytesMessage sendMessage = new JmsBytesMessage(sendData); // Throws out NullPointerException // sendMessage.writeBytes("hello again".getBytes()); } } ================================================ FILE: rocketmq-jms/core/src/test/java/org/apache/rocketmq/jms/domain/message/JmsMessageConvertTest.java ================================================ package org.apache.rocketmq.jms.domain.message; import org.apache.rocketmq.common.message.MessageConst; import org.apache.rocketmq.common.message.MessageExt; import org.apache.rocketmq.jms.domain.JmsBaseConstant; import org.apache.rocketmq.jms.domain.JmsBaseTopic; import org.apache.rocketmq.jms.util.MessageConverter; import org.apache.rocketmq.jms.util.MsgConvertUtil; import org.junit.Assert; import org.junit.Test; public class JmsMessageConvertTest { @Test public void testCovert2RMQ() throws Exception { //init jmsBaseMessage String topic = "TestTopic"; String messageType = "TagA"; JmsBaseMessage jmsBaseMessage = new JmsTextMessage("testText"); jmsBaseMessage.setHeader(JmsBaseConstant.JMS_DESTINATION, new JmsBaseTopic(topic, messageType)); jmsBaseMessage.setHeader(JmsBaseConstant.JMS_MESSAGE_ID, "ID:null"); jmsBaseMessage.setHeader(JmsBaseConstant.JMS_REDELIVERED, Boolean.FALSE); jmsBaseMessage.setObjectProperty(MsgConvertUtil.JMS_MSGMODEL, MsgConvertUtil.MSGMODEL_TEXT); jmsBaseMessage.setObjectProperty(MsgConvertUtil.MSG_TOPIC, topic); jmsBaseMessage.setObjectProperty(MsgConvertUtil.MSG_TYPE, messageType); jmsBaseMessage.setObjectProperty(MessageConst.PROPERTY_TAGS, messageType); jmsBaseMessage.setObjectProperty(MessageConst.PROPERTY_KEYS, messageType); //convert to RMQMessage MessageExt message = (MessageExt)MessageConverter.convert2RMQMessage(jmsBaseMessage); System.out.println(message); //then convert back to jmsBaseMessage JmsBaseMessage jmsBaseMessageBack = MessageConverter.convert2JMSMessage(message); JmsTextMessage jmsTextMessage = (JmsTextMessage) jmsBaseMessage; JmsTextMessage jmsTextMessageBack = (JmsTextMessage) jmsBaseMessageBack; Assert.assertEquals(jmsTextMessage.getText(), jmsTextMessageBack.getText()); Assert.assertEquals(jmsTextMessage.getJMSDestination().toString(), jmsTextMessageBack.getJMSDestination().toString()); Assert.assertEquals(jmsTextMessage.getJMSMessageID(), jmsTextMessageBack.getJMSMessageID()); Assert.assertEquals(jmsTextMessage.getJMSRedelivered(), jmsTextMessageBack.getJMSRedelivered()); Assert.assertEquals(jmsTextMessage.getHeaders().get(MsgConvertUtil.JMS_MSGMODEL), jmsTextMessageBack.getHeaders().get(MsgConvertUtil.JMS_MSGMODEL)); Assert.assertEquals(jmsTextMessage.getHeaders().get(MsgConvertUtil.MSG_TOPIC), jmsTextMessageBack.getHeaders().get(MsgConvertUtil.MSG_TOPIC)); Assert.assertEquals(jmsTextMessage.getHeaders().get(MsgConvertUtil.MSG_TYPE), jmsTextMessageBack.getHeaders().get(MsgConvertUtil.MSG_TYPE)); Assert.assertEquals(jmsTextMessage.getHeaders().get(MessageConst.PROPERTY_TAGS), jmsTextMessageBack.getHeaders().get(MessageConst.PROPERTY_TAGS)); Assert.assertEquals(jmsTextMessage.getHeaders().get(MessageConst.PROPERTY_KEYS), jmsTextMessageBack.getHeaders().get(MessageConst.PROPERTY_KEYS)); } } ================================================ FILE: rocketmq-jms/core/src/test/java/org/apache/rocketmq/jms/domain/message/JmsObjectMessageTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain.message; import java.io.Serializable; import javax.jms.JMSException; import org.junit.Assert; import org.junit.Test; public class JmsObjectMessageTest { @Test public void testGetObject() { JmsObjectMessage jmsObjectMessage = new JmsObjectMessage(new User("jack", 20)); try { Assert.assertEquals(jmsObjectMessage.getObject(), new User("jack", 20)); } catch (JMSException e) { e.printStackTrace(); } } @Test public void testGetBody() { JmsObjectMessage jmsObjectMessage = new JmsObjectMessage(new User("jack", 20)); try { User user = (User)jmsObjectMessage.getBody(Object.class); System.out.println(user.getName() + ": " + user.getAge()); Assert.assertEquals(jmsObjectMessage.getBody(Object.class), jmsObjectMessage.getObject()); } catch (JMSException e) { e.printStackTrace(); } } private class User implements Serializable { private String name; private int age; private User(String name, int age) { this.name = name; this.age = age; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null || getClass() != obj.getClass()) return false; User user = (User)obj; if (age != user.getAge()) return false; if (name != null ? !name.equals(user.getName()) : user.getName() != null) return false; return true; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } } } ================================================ FILE: rocketmq-jms/core/src/test/java/org/apache/rocketmq/jms/domain/message/JmsTextMessageTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.domain.message; import javax.jms.JMSException; import org.junit.Assert; import org.junit.Test; public class JmsTextMessageTest { private String text = "jmsTextMessage test"; @Test public void testGetBody() { JmsTextMessage jmsTextMessage = new JmsTextMessage(text); try { Assert.assertEquals(jmsTextMessage.getBody(String.class), text); } catch (JMSException e) { e.printStackTrace(); } } @Test public void testSetGetText() { JmsTextMessage jmsTextMessage = new JmsTextMessage(); jmsTextMessage.setText(text); try { Assert.assertEquals(jmsTextMessage.getText(), text); } catch (JMSException e) { e.printStackTrace(); } } } ================================================ FILE: rocketmq-jms/core/src/test/java/org/apache/rocketmq/jms/integration/IntegrationTestBase.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.integration; import org.apache.rocketmq.broker.BrokerController; import org.apache.rocketmq.client.exception.MQClientException; import org.apache.rocketmq.common.BrokerConfig; import org.apache.rocketmq.common.TopicConfig; import org.apache.rocketmq.common.namesrv.NamesrvConfig; import org.apache.rocketmq.jms.domain.CommonConstant; import org.apache.rocketmq.namesrv.NamesrvController; import org.apache.rocketmq.remoting.netty.NettyClientConfig; import org.apache.rocketmq.remoting.netty.NettyServerConfig; import org.apache.rocketmq.store.config.MessageStoreConfig; import org.apache.rocketmq.tools.admin.DefaultMQAdminExt; import java.io.File; import java.util.ArrayList; import java.util.List; import java.util.Random; import java.util.UUID; import java.util.concurrent.atomic.AtomicInteger; import org.junit.Assert; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class IntegrationTestBase { public static Logger logger = LoggerFactory.getLogger(IntegrationTestBase.class); protected static Random random = new Random(); protected static final String SEP = File.separator; protected static String topic = "jms-test"; protected static String topic2 = "jms-test-2"; protected static String messageType = "TagA"; protected static String producerId = "PID-jms-test"; protected static String consumerId = "CID-jms-test"; protected static String consumerId2 = "CID-jms-test-2"; protected static String nameServer; protected static String text = "English test"; protected static int consumeThreadNums = 16; protected static final String BROKER_NAME_PREFIX = "TestBrokerName_"; protected static final AtomicInteger BROKER_INDEX = new AtomicInteger(0); protected static final List TMPE_FILES = new ArrayList(); protected static final List BROKER_CONTROLLERS = new ArrayList(); protected static final List NAMESRV_CONTROLLERS = new ArrayList(); private static String createBaseDir() { String baseDir = System.getProperty("user.home") + SEP + "unitteststore-" + UUID.randomUUID(); final File file = new File(baseDir); if (file.exists()) { System.out.println(String.format("[%s] has already existed, please bake up and remove it for integration tests", baseDir)); System.exit(1); } TMPE_FILES.add(file); return baseDir; } public static NamesrvController createAndStartNamesrv() { String baseDir = createBaseDir(); NamesrvConfig namesrvConfig = new NamesrvConfig(); NettyServerConfig nameServerNettyServerConfig = new NettyServerConfig(); namesrvConfig.setKvConfigPath(baseDir + SEP + "namesrv" + SEP + "kvConfig.json"); nameServerNettyServerConfig.setListenPort(9000 + random.nextInt(1000)); NamesrvController namesrvController = new NamesrvController(namesrvConfig, nameServerNettyServerConfig); try { Assert.assertTrue(namesrvController.initialize()); logger.info("Name Server Start:{}", nameServerNettyServerConfig.getListenPort()); namesrvController.start(); } catch (Exception e) { System.out.println("Name Server start failed"); System.exit(1); } NAMESRV_CONTROLLERS.add(namesrvController); return namesrvController; } public static BrokerController createAndStartBroker(String nsAddr) { String baseDir = createBaseDir(); BrokerConfig brokerConfig = new BrokerConfig(); NettyServerConfig nettyServerConfig = new NettyServerConfig(); NettyClientConfig nettyClientConfig = new NettyClientConfig(); MessageStoreConfig storeConfig = new MessageStoreConfig(); brokerConfig.setBrokerName(BROKER_NAME_PREFIX + BROKER_INDEX.getAndIncrement()); brokerConfig.setBrokerIP1("127.0.0.1"); brokerConfig.setNamesrvAddr(nsAddr); storeConfig.setStorePathRootDir(baseDir); storeConfig.setStorePathCommitLog(baseDir + SEP + "commitlog"); storeConfig.setHaListenPort(8000 + random.nextInt(1000)); nettyServerConfig.setListenPort(10000 + random.nextInt(1000)); BrokerController brokerController = new BrokerController(brokerConfig, nettyServerConfig, nettyClientConfig, storeConfig); try { Assert.assertTrue(brokerController.initialize()); logger.info("Broker Start name:{} addr:{}", brokerConfig.getBrokerName(), brokerController.getBrokerAddr()); brokerController.start(); } catch (Exception e) { System.out.println("Broker start failed"); System.exit(1); } BROKER_CONTROLLERS.add(brokerController); return brokerController; } protected static DefaultMQAdminExt defaultMQAdminExt; static { //clear the environment Runtime.getRuntime().addShutdownHook(new Thread() { @Override public void run() { if (defaultMQAdminExt != null) { defaultMQAdminExt.shutdown(); } for (NamesrvController namesrvController: NAMESRV_CONTROLLERS) { if (namesrvController != null) { namesrvController.shutdown(); } } for (BrokerController brokerController: BROKER_CONTROLLERS) { if (brokerController != null) { brokerController.shutdown(); } } for (File file : TMPE_FILES) { deleteFile(file); } } }); NamesrvController namesrvController = IntegrationTestBase.createAndStartNamesrv(); nameServer = "127.0.0.1:" + namesrvController.getNettyServerConfig().getListenPort(); BrokerController brokerController = createAndStartBroker(nameServer); defaultMQAdminExt = new DefaultMQAdminExt(); defaultMQAdminExt.setNamesrvAddr(nameServer); try { defaultMQAdminExt.start(); } catch (MQClientException e) { System.out.println("DefaultMQAdminExt start failed"); System.exit(1); } createTopic(topic, brokerController.getBrokerAddr()); } public static void deleteFile(File file) { if (!file.exists()) { return; } if (file.isFile()) { file.delete(); } else if (file.isDirectory()) { File[] files = file.listFiles(); for (int i = 0;i < files.length;i ++) { deleteFile(files[i]); } file.delete(); } } public static void createTopic(String topic, String addr) { TopicConfig topicConfig = new TopicConfig(); topicConfig.setTopicName(topic); topicConfig.setReadQueueNums(4); topicConfig.setWriteQueueNums(4); try { defaultMQAdminExt.createAndUpdateTopicConfig(addr, topicConfig); } catch (Exception e) { logger.error("Create topic:{} addr:{} failed", addr, topic); } } } ================================================ FILE: rocketmq-jms/core/src/test/java/org/apache/rocketmq/jms/integration/JmsClientIT.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.integration; import java.net.URI; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import javax.jms.Connection; import javax.jms.Destination; import javax.jms.MessageConsumer; import javax.jms.MessageProducer; import javax.jms.Session; import javax.jms.TextMessage; import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer; import org.apache.rocketmq.client.producer.DefaultMQProducer; import org.apache.rocketmq.jms.JmsTestListener; import org.apache.rocketmq.jms.JmsTestUtil; import org.apache.rocketmq.jms.domain.CommonConstant; import org.apache.rocketmq.jms.domain.JmsBaseConnectionFactory; import org.junit.Assert; import org.junit.Test; import static org.apache.rocketmq.jms.JmsTestUtil.getRMQPushConsumerExt; public class JmsClientIT extends IntegrationTestBase { @Test public void testConfigInURI() throws Exception { JmsBaseConnectionFactory connectionFactory = new JmsBaseConnectionFactory(new URI(String.format("rocketmq://xxx?%s=%s&%s=%s&%s=%s&%s=%s&%s=%s&%s=%s", CommonConstant.PRODUCERID, producerId, CommonConstant.CONSUMERID, consumerId, CommonConstant.NAMESERVER, nameServer, CommonConstant.CONSUME_THREAD_NUMS, consumeThreadNums, CommonConstant.SEND_TIMEOUT_MILLIS, 10*1000, CommonConstant.INSTANCE_NAME, "JMS_TEST"))); Connection connection = connectionFactory.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); connection.start(); try { Destination destination = session.createTopic(topic + ":" + messageType); session.createConsumer(destination); session.createProducer(destination); DefaultMQPushConsumer rmqPushConsumer = (DefaultMQPushConsumer) getRMQPushConsumerExt(consumerId).getConsumer(); Assert.assertNotNull(rmqPushConsumer); Assert.assertEquals(consumerId, rmqPushConsumer.getConsumerGroup()); Assert.assertEquals("JMS_TEST", rmqPushConsumer.getInstanceName()); Assert.assertEquals(consumeThreadNums, rmqPushConsumer.getConsumeThreadMax()); Assert.assertEquals(consumeThreadNums, rmqPushConsumer.getConsumeThreadMin()); Assert.assertEquals(nameServer, rmqPushConsumer.getNamesrvAddr()); DefaultMQProducer mqProducer = (DefaultMQProducer) JmsTestUtil.getMQProducer(producerId); Assert.assertNotNull(mqProducer); Assert.assertEquals(producerId, mqProducer.getProducerGroup()); Assert.assertEquals("JMS_TEST", mqProducer.getInstanceName()); Assert.assertEquals(10 * 1000, mqProducer.getSendMsgTimeout()); Assert.assertEquals(nameServer, mqProducer.getNamesrvAddr()); Thread.sleep(2000); } finally { connection.close(); } } private Connection createConnection(String producerGroup, String consumerGroup) throws Exception { JmsBaseConnectionFactory connectionFactory = new JmsBaseConnectionFactory(new URI(String.format("rocketmq://xxx?%s=%s&%s=%s&%s=%s&%s=%s&%s=%s&%s=%s", CommonConstant.PRODUCERID, producerGroup, CommonConstant.CONSUMERID, consumerGroup, CommonConstant.NAMESERVER, nameServer, CommonConstant.CONSUME_THREAD_NUMS, consumeThreadNums, CommonConstant.SEND_TIMEOUT_MILLIS, 10*1000, CommonConstant.INSTANCE_NAME, "JMS_TEST"))); return connectionFactory.createConnection(); } @Test public void testProducerAndConsume_TwoConsumer() throws Exception { Connection connection = createConnection(producerId, consumerId); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Destination destinationA = session.createTopic("TopicA"); Destination destinationB = session.createTopic("TopicB"); final CountDownLatch countDownLatch = new CountDownLatch(2); JmsTestListener listenerA = new JmsTestListener(10,countDownLatch); JmsTestListener listenerB = new JmsTestListener(10, countDownLatch); try { //two consumers MessageConsumer messageConsumerA = session.createConsumer(destinationA); messageConsumerA.setMessageListener(listenerA); MessageConsumer messageConsumerB = session.createConsumer(destinationB); messageConsumerB.setMessageListener(listenerB); //producer MessageProducer messageProducer = session.createProducer(destinationA); connection.start(); for (int i = 0; i < 10; i++) { TextMessage message = session.createTextMessage(text + i); Assert.assertNull(message.getJMSMessageID()); messageProducer.send(message); Assert.assertNotNull(message.getJMSMessageID()); } for (int i = 0; i < 10; i++) { TextMessage message = session.createTextMessage(text + i); Assert.assertNull(message.getJMSMessageID()); messageProducer.send(destinationB, message); Assert.assertNotNull(message.getJMSMessageID()); } if (countDownLatch.await(30, TimeUnit.SECONDS)) { Thread.sleep(2000); } Assert.assertEquals(10, listenerA.getConsumedNum()); Assert.assertEquals(10, listenerB.getConsumedNum()); } finally { //Close the connection connection.close(); } } @Test public void testProducerAndConsume_TagFilter() throws Exception { Connection connection = createConnection(producerId, consumerId); Connection anotherConnection = createConnection(producerId, consumerId +"other"); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Session anotherSession = anotherConnection.createSession(false, Session.AUTO_ACKNOWLEDGE); Destination destinationA = session.createTopic("topic:tagA"); Destination destinationB = session.createTopic("topic:tagB"); final CountDownLatch countDownLatch = new CountDownLatch(2); JmsTestListener listenerForTagA = new JmsTestListener(10, countDownLatch); JmsTestListener listenerForAll = new JmsTestListener(40, countDownLatch); try { session.createConsumer(destinationA).setMessageListener(listenerForTagA); anotherSession.createConsumer(session.createTopic("topic")).setMessageListener(listenerForAll); //producer MessageProducer messageProducer = session.createProducer(destinationA); connection.start(); anotherConnection.start(); for (int i = 0; i < 20; i++) { TextMessage message = session.createTextMessage(text + i); Assert.assertNull(message.getJMSMessageID()); messageProducer.send(message); Assert.assertNotNull(message.getJMSMessageID()); } for (int i = 0; i < 20; i++) { TextMessage message = session.createTextMessage(text + i); Assert.assertNull(message.getJMSMessageID()); messageProducer.send(destinationB, message); Assert.assertNotNull(message.getJMSMessageID()); } if (countDownLatch.await(30, TimeUnit.SECONDS)) { Thread.sleep(2000); } Assert.assertEquals(20, listenerForTagA.getConsumedNum()); Assert.assertEquals(40, listenerForAll.getConsumedNum()); } finally { //Close the connection connection.close(); anotherConnection.close(); } } } ================================================ FILE: rocketmq-jms/core/src/test/java/org/apache/rocketmq/jms/integration/JmsConsumerIT.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.integration; import java.net.URI; import javax.jms.Connection; import javax.jms.Destination; import javax.jms.Message; import javax.jms.MessageConsumer; import javax.jms.MessageListener; import javax.jms.Session; import org.apache.rocketmq.jms.domain.JmsBaseConnectionFactory; import org.apache.rocketmq.jms.domain.JmsBaseMessageConsumer; import org.apache.rocketmq.jms.domain.RMQPushConsumerExt; import org.junit.Assert; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import static org.apache.rocketmq.jms.JmsTestUtil.checkConsumerState; import static org.apache.rocketmq.jms.JmsTestUtil.getRMQPushConsumerExt; public class JmsConsumerIT extends IntegrationTestBase { private final Logger logger = LoggerFactory.getLogger(getClass()); private MessageListener listener = new MessageListener() { @Override public void onMessage(Message message) { try { Assert.assertNotNull(message); Assert.assertNotNull(message.getJMSMessageID()); } catch (Exception e) { throw new RuntimeException(e); } } }; @Test public void testStartIdempotency() throws Exception { JmsBaseConnectionFactory connectionFactory = new JmsBaseConnectionFactory(new URI("rocketmq://xxx?consumerId=" + consumerId + "&nameServer=" + nameServer)); Connection connection = connectionFactory.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); checkConsumerState(consumerId, true, false); try { Destination destination = session.createTopic(topic + ":" + messageType); MessageConsumer consumer = session.createConsumer(destination); consumer.setMessageListener(listener); checkConsumerState(consumerId, false, false); ((JmsBaseMessageConsumer) consumer).startConsumer(); checkConsumerState(consumerId, false, true); Destination destination1 = session.createTopic(topic2 + ":" + messageType); MessageConsumer consumer1 = session.createConsumer(destination1); consumer1.setMessageListener(listener); ((JmsBaseMessageConsumer) consumer1).startConsumer(); checkConsumerState(consumerId, false, true); //the start is idempotent connection.start(); connection.start(); Thread.sleep(5000); } finally { connection.close(); } } @Test public void testReferenceCount() throws Exception { JmsBaseConnectionFactory connectionFactory = new JmsBaseConnectionFactory(new URI("rocketmq://xxx?consumerId=" + consumerId + "&nameServer=" + nameServer)); Connection connection = connectionFactory.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); connection.start(); try { Destination destination = session.createTopic(topic + ":" + messageType); MessageConsumer consumer = session.createConsumer(destination); consumer.setMessageListener(listener); RMQPushConsumerExt rmqPushConsumerExt = getRMQPushConsumerExt(consumerId); Assert.assertNotNull(rmqPushConsumerExt); Assert.assertEquals(1, rmqPushConsumerExt.getReferenceCount()); MessageConsumer consumer2 = session.createConsumer(destination); Assert.assertEquals(2, rmqPushConsumerExt.getReferenceCount()); MessageConsumer consumer3 = session.createConsumer(session.createTopic(topic + ":" + messageType)); Assert.assertEquals(3, rmqPushConsumerExt.getReferenceCount()); session.close(); Assert.assertEquals(0, rmqPushConsumerExt.getReferenceCount()); Assert.assertEquals(false, rmqPushConsumerExt.isStarted()); Assert.assertNull(getRMQPushConsumerExt(consumerId)); Thread.sleep(5000); } finally { connection.close(); } } } ================================================ FILE: rocketmq-jms/core/src/test/java/org/apache/rocketmq/jms/util/URISpecParserTest.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.util; import java.util.Map; import org.junit.Test; public class URISpecParserTest { @Test public void parseURI_NormalTest() { Map result = URISpecParser.parseURI("rocketmq://localhost"); System.out.println(result); result = URISpecParser .parseURI("rocketmq://xxx?appId=test&consumerId=testGroup"); System.out.println(result); result = URISpecParser.parseURI("rocketmq:!@#$%^&*()//localhost?appId=test!@#$%^&*()"); System.out.println(result); } @Test(expected = IllegalArgumentException.class) public void parseURI_AbnormalTest() { URISpecParser.parseURI("metaq3://localhost?appId=test"); } } ================================================ FILE: rocketmq-jms/pom.xml ================================================ 4.0.0 org.apache.rocketmq rocketmq-jms-all pom 1.0-SNAPSHOT spring core UTF-8 false true 1.6 1.6 2.19.1 4.0.0-incubating org.apache.rocketmq rocketmq-client ${rocketmq.version} javax.jms jms-api 1.1-rev-1 com.google.guava guava 18.0 commons-lang commons-lang 2.6 junit junit test 4.12 org.apache.rocketmq rocketmq-namesrv ${rocketmq.version} test org.apache.rocketmq rocketmq-broker ${rocketmq.version} test maven-compiler-plugin 3.5.1 ${maven.compiler.source} ${maven.compiler.target} ${maven.compiler.source} true true org.jacoco jacoco-maven-plugin 0.7.8 default-prepare-agent prepare-agent ${project.build.directory}/jacoco.exec default-prepare-agent-integration pre-integration-test prepare-agent-integration ${project.build.directory}/jacoco-it.exec failsafeArgLine default-report report default-report-integration report-integration maven-surefire-plugin ${surefire.version} maven-failsafe-plugin ${surefire.version} 1 true @{failsafeArgLine} integration-test verify org.eluder.coveralls coveralls-maven-plugin 4.3.0 maven-checkstyle-plugin 2.17 verify verify style/rmq_checkstyle.xml UTF-8 true true check src/main/resources true ================================================ FILE: rocketmq-jms/spring/pom.xml ================================================ rocketmq-jms-all org.apache.rocketmq 1.0-SNAPSHOT 4.0.0 rocketmq-jms-spring 1.0-SNAPSHOT UTF-8 4.1.4.RELEASE ${project.parent.groupId} rocketmq-jms ${project.parent.version} org.springframework spring-jms ${spring-version} true ${project.parent.groupId} rocketmq-jms ${project.parent.version} test-jar test org.testng testng 6.8.21 test ================================================ FILE: rocketmq-jms/spring/src/main/java/org/apache/rocketmq/jms/spring/SimpleExMessageListenerContainer.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.spring; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.MessageConsumer; import javax.jms.MessageListener; import javax.jms.Session; import org.springframework.jms.listener.SimpleMessageListenerContainer; public class SimpleExMessageListenerContainer extends SimpleMessageListenerContainer { private String cacheLevelName; /** * Create a MessageConsumer for the given JMS Session, registering a * MessageListener for the specified listener. * * @param session * the JMS Session to work on * * @return the MessageConsumer * * @throws JMSException * if thrown by JMS methods * @see #executeListener */ protected MessageConsumer createListenerConsumer(final Session session) throws JMSException { Destination destination = getDestination(); if (destination == null) { destination = resolveDestinationName(session, getDestinationName()); } MessageConsumer consumer = createConsumer(session, destination); consumer.setMessageListener((MessageListener) super.getMessageListener()); return consumer; } /** * Create a JMS MessageConsumer for the given Session and Destination. *

* This implementation uses JMS 1.1 API. * * @param session * the JMS Session to create a MessageConsumer for * @param destination * the JMS Destination to create a MessageConsumer for * * @return the new JMS MessageConsumer * * @throws JMSException * if thrown by JMS API methods */ protected MessageConsumer createConsumer(Session session, Destination destination) throws JMSException { //ONS not support message selector and other features nowadays return session.createConsumer(destination); } /** * @return the cacheLevelName */ public String getCacheLevelName() { return cacheLevelName; } /** * @param cacheLevelName * the cacheLevelName to set */ public void setCacheLevelName(String cacheLevelName) { this.cacheLevelName = cacheLevelName; } } ================================================ FILE: rocketmq-jms/spring/src/test/java/org/apache/rocketmq/jms/spring/JmsConsumeIT.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.spring; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import javax.jms.JMSException; import javax.jms.MessageProducer; import javax.jms.Session; import javax.jms.Topic; import org.apache.rocketmq.jms.JmsTestListener; import org.apache.rocketmq.jms.domain.message.JmsTextMessage; import org.springframework.jms.core.ProducerCallback; import org.testng.Assert; import org.testng.annotations.Test; public class JmsConsumeIT extends JmsProduceIT { @Test public void testConsume() throws Exception { final Topic topic = (Topic) consumeContext.getBean("baseTopic"); JmsTestListener messageListener = (JmsTestListener) consumeContext.getBean("messageListener"); CountDownLatch countDownLatch = new CountDownLatch(1); messageListener.setLatch(countDownLatch); messageListener.setExpectd(30); consumeContext.start(); for (int i = 0; i < 30; i++) { jmsTemplate.execute(topic, new ProducerCallback() { @Override public Object doInJms(Session session, MessageProducer producer) throws JMSException { JmsTextMessage message = (JmsTextMessage) session.createTextMessage("hello world,kafka, haha"); producer.send(topic, message); Assert.assertNotNull(message.getJMSMessageID()); return message; } }); } if (countDownLatch.await(30, TimeUnit.SECONDS)) { Thread.sleep(2000); } Assert.assertEquals(30, messageListener.getConsumedNum()); consumeContext.close(); } } ================================================ FILE: rocketmq-jms/spring/src/test/java/org/apache/rocketmq/jms/spring/JmsProduceIT.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.spring; import com.google.common.collect.Lists; import javax.jms.JMSException; import javax.jms.MessageProducer; import javax.jms.Session; import javax.jms.Topic; import org.apache.rocketmq.jms.domain.message.JmsBytesMessage; import org.apache.rocketmq.jms.domain.message.JmsObjectMessage; import org.apache.rocketmq.jms.domain.message.JmsTextMessage; import org.springframework.jms.core.JmsTemplate; import org.springframework.jms.core.ProducerCallback; import org.testng.Assert; import org.testng.annotations.Test; public class JmsProduceIT extends SpringTestBase { protected JmsTemplate jmsTemplate = (JmsTemplate) produceContext.getBean("jmsTemplate"); private Topic destination = (Topic) produceContext.getBean("destination"); @Test public void simpleSendTest() throws Exception { //Send text message jmsTemplate.execute(destination, new ProducerCallback() { @Override public Object doInJms(Session session, MessageProducer producer) throws JMSException { JmsTextMessage message = (JmsTextMessage) session.createTextMessage("hello world,kafka"); producer.send(destination, message); Assert.assertNotNull(message.getJMSMessageID()); return message; } }); //Send object message jmsTemplate.execute(destination, new ProducerCallback() { @Override public Object doInJms(Session session, MessageProducer producer) throws JMSException { JmsObjectMessage message = (JmsObjectMessage) session.createObjectMessage(Lists.newArrayList(1, 2, 3)); producer.send(destination, message); Assert.assertNotNull(message.getJMSMessageID()); return message; } }); //Send byte message jmsTemplate.execute(destination, new ProducerCallback() { @Override public Object doInJms(Session session, MessageProducer producer) throws JMSException { byte[] ts = "Von,Test".getBytes(); JmsBytesMessage message = (JmsBytesMessage) session.createBytesMessage(); message.writeBytes(ts); producer.send(destination, message); Assert.assertNotNull(message.getJMSMessageID()); return message; } }); } @Test(threadPoolSize = 2, invocationCount = 20) public void multiSenderTest() throws Exception { jmsTemplate.execute(destination, new ProducerCallback() { @Override public Object doInJms(Session session, MessageProducer producer) throws JMSException { byte[] ts = "Von,Multi thread sender test".getBytes(); JmsBytesMessage message = (JmsBytesMessage) session.createBytesMessage(); message.writeBytes(ts); producer.send(destination, message); Assert.assertNotNull(message.getJMSMessageID()); return message; } }); } } ================================================ FILE: rocketmq-jms/spring/src/test/java/org/apache/rocketmq/jms/spring/SpringTestBase.java ================================================ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */ package org.apache.rocketmq.jms.spring; import org.apache.rocketmq.jms.domain.CommonConstant; import org.apache.rocketmq.jms.integration.IntegrationTestBase; import org.springframework.context.support.ClassPathXmlApplicationContext; public class SpringTestBase extends IntegrationTestBase{ protected final static ClassPathXmlApplicationContext produceContext; protected final static ClassPathXmlApplicationContext consumeContext; static { String rmqJmsUrl = String.format("rocketmq://xxx?%s=%s&%s=%s&%s=%s&%s=%s&%s=%s&%s=%s", CommonConstant.PRODUCERID, producerId, CommonConstant.CONSUMERID, consumerId, CommonConstant.NAMESERVER, nameServer, CommonConstant.CONSUME_THREAD_NUMS, consumeThreadNums, CommonConstant.SEND_TIMEOUT_MILLIS, 10*1000, CommonConstant.INSTANCE_NAME, "JMS_TEST"); System.setProperty("RMQ_JMS_URL", rmqJmsUrl); produceContext = new ClassPathXmlApplicationContext("classpath:producer.xml"); consumeContext = new ClassPathXmlApplicationContext("classpath:consumer.xml"); } } ================================================ FILE: rocketmq-jms/spring/src/test/resources/consumer.xml ================================================ ================================================ FILE: rocketmq-jms/spring/src/test/resources/producer.xml ================================================ ================================================ FILE: rocketmq-jms/style/copyright/Apache.xml ================================================ ================================================ FILE: rocketmq-jms/style/copyright/profiles_settings.xml ================================================ ================================================ FILE: rocketmq-jms/style/rmq_checkstyle.xml ================================================ ================================================ FILE: rocketmq-jms/style/rmq_codeStyle.xml ================================================ ================================================ FILE: rocketmq-knative/source/Dockerfile.adapter ================================================ # Build the manager binary FROM registry.cn-hangzhou.aliyuncs.com/knative-sample/golang:1.12.9 as builder # Copy in the go src WORKDIR /go/src/github.com/apache/rocketmq-externals/rocketmq-knative/source/ COPY cmd/ cmd/ COPY pkg/ pkg/ COPY vendor/ vendor/ # Build RUN mkdir -p rocketmq/apacherocketmq/bin/ RUN CGO_ENABLED=1 GOOS=linux GOARCH=amd64 go build -a -o rocketmq/apacherocketmq/bin/receive_adapter cmd/receive_adapter/main.go FROM registry.cn-beijing.aliyuncs.com/knative-sample/centos:7.6.1810 WORKDIR /app/ RUN mkdir -p /app/{bin,config/kodata}/ && echo "ref: refs/heads/master" >/app/config/kodata/HEAD COPY --from=builder /go/src/github.com/apache/rocketmq-externals/rocketmq-knative/source/rocketmq/apacherocketmq/bin/receive_adapter /app/bin/receive_adapter ENV KO_DATA_PATH=/app/config/kodata ENTRYPOINT ["/app/bin/receive_adapter"] ================================================ FILE: rocketmq-knative/source/Dockerfile.controller ================================================ # Build the manager binary FROM registry.cn-hangzhou.aliyuncs.com/knative-sample/golang:1.12.9 as builder # Copy in the go src WORKDIR /go/src/github.com/apache/rocketmq-externals/rocketmq-knative/source/ COPY cmd/ cmd/ COPY pkg/ pkg/ COPY vendor/ vendor/ #WORKDIR /root/rocketmq-source #COPY . ./ # Build ENV GOPROXY=https://goproxy.cn RUN mkdir -p rocketmq/apacherocketmq/bin/ RUN CGO_ENABLED=1 GOOS=linux GOARCH=amd64 go build -o rocketmq/apacherocketmq/bin/rocketmqsource cmd/controller/main.go FROM registry.cn-beijing.aliyuncs.com/knative-sample/centos:7.6.1810 WORKDIR /app/ RUN mkdir -p /app/{bin,config/kodata}/ && echo "ref: refs/heads/master" >/app/config/kodata/HEAD COPY --from=builder /go/src/github.com/apache/rocketmq-externals/rocketmq-knative/source/rocketmq/apacherocketmq/bin/rocketmqsource /app/bin/rocketmqsource ENV KO_DATA_PATH=/app/config/kodata ENTRYPOINT ["/app/bin/rocketmqsource"] ================================================ FILE: rocketmq-knative/source/README.md ================================================ ## RocketMQ Source [![License](https://img.shields.io/badge/license-Apache%202-4EB1BA.svg)](https://www.apache.org/licenses/LICENSE-2.0.html) [![Language](https://img.shields.io/badge/Language-Go-blue.svg)](https://golang.org/) ## Overview RocketMQSource which is a separate Kubernetes custom resource fires a new event each time an event is published on an Apache RocketMQ Cluster. ## Quick Start ### build RocketMQ Source 1 Clone the project on your Kubernetes cluster master node: ``` $ git clone https://github.com/apache/rocketmq-externals $ cd rocketmq-externals/rocketmq-knative/source ``` 2.build controller and adapter ``` $ docker build -f Dockerfile.adapter -t rocketmqsource-adapter . $ docker build -f Dockerfile.controller -t rocketmqsource-controller . ``` 3 push image to docker hub ``` $ docker tag rocketmqsource-adapter $dockerhub-user/rocketmqsource-adapter:$version-adapter $ docker push $dockerhub-user/rocketmqsource-adapter:$version-adapter $ docker tag rocketmqsource-adapter $dockerhub-user/rocketmqsource-adapter:$version-adapter $ docker push $dockerhub-user/rocketmqsource-adapter:$version-adapter ``` ### Deploy RocketMQ Source 1 update the version of docker image ``` $ vi config/500-controller.yaml ``` 2 deploy the controller of rocketmqsource ``` $ kubectl apply -f 300-rocketmqsource.yaml -f 400-controller-service.yaml -f 500-controller.yaml -f 600-istioegress.yaml -f 200-serviceaccount.yaml -f 201-clusterrole.yaml -f 202-clusterrolebinding.yaml ``` 3 check the controller pod ``` $ kubectl -n knative-sources get pods NAME READY STATUS RESTARTS AGE rocketmqsource-controller-manager-0 1/1 Running 0 23h ``` ================================================ FILE: rocketmq-knative/source/cmd/controller/main.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package main import ( "log" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis" controller "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/reconciler" "go.uber.org/zap" "go.uber.org/zap/zapcore" "knative.dev/pkg/logging/logkey" "sigs.k8s.io/controller-runtime/pkg/client/config" "sigs.k8s.io/controller-runtime/pkg/manager" "sigs.k8s.io/controller-runtime/pkg/runtime/signals" ) func main() { logCfg := zap.NewProductionConfig() logCfg.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder logger, err := logCfg.Build() if err != nil { log.Fatal(err) } logger = logger.With(zap.String(logkey.ControllerType, "rocketmqsource-controller")) if err != nil { log.Fatal(err) } cfg, err := config.GetConfig() if err != nil { log.Fatal(err) } // Create a new Cmd to provide shared dependencies and start components mgr, err := manager.New(cfg, manager.Options{}) if err != nil { log.Fatal(err) } log.Printf("Registering Components.") // Setup Scheme for all resources if err := apis.AddToScheme(mgr.GetScheme()); err != nil { log.Fatal(err) } log.Printf("Setting up Controller.") // Setup RocketMQSource Controller if err := controller.Add(mgr, logger.Sugar()); err != nil { log.Fatal(err) } log.Printf("Starting rocketmqsource controller.") // Start the Cmd log.Fatal(mgr.Start(signals.SetupSignalHandler())) } ================================================ FILE: rocketmq-knative/source/cmd/receive_adapter/main.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package main import ( "flag" "log" "fmt" "github.com/kelseyhightower/envconfig" rocketmq "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/adapter" "go.uber.org/zap" "go.uber.org/zap/zapcore" "golang.org/x/net/context" "k8s.io/client-go/kubernetes" "k8s.io/client-go/rest" ) type envConfig struct { Namespace string `envconfig:"NAMESPACE" required:"true"` SecretName string `envconfig:"SECRET_NAME" required:"true"` SecretKey string `envconfig:"SECRET_KEY" required:"true"` Sink string `envconfig:"SINK_URI" required:"true"` Topic string `envconfig:"TOPIC" default:""` NamesrvAddr string `envconfig:"NAMESRVADDR" default:""` RNamespace string `envconfig:"RNAMESPACE" default:""` GroupName string `envconfig:"GROUPNAME" default:""` Subscription string `envconfig:"SUBSCRIPTION_ID" required:"true"` } func main() { flag.Parse() ctx := context.Background() logCfg := zap.NewProductionConfig() logCfg.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder logger, err := logCfg.Build() if err != nil { log.Fatalf("Unable to create logger: %v", err) } var env envConfig if err := envconfig.Process("", &env); err != nil { logger.Fatal("Failed to process env var", zap.Error(err)) } client, err := newKubernetesClient() if err != nil { logger.Fatal("Failed to initialize kubernetes client: ", zap.Error(err)) } adapter := &rocketmq.Adapter{ Namespace: env.Namespace, SecretName: env.SecretName, SecretKey: env.SecretKey, K8sClient: client, Topic: env.Topic, NamesrvAddr: env.NamesrvAddr, RNamespace: env.RNamespace, GroupName: env.GroupName, SinkURI: env.Sink, SubscriptionID: env.Subscription, } logger.Info("Starting RocketMQ Receive Adapter. %v", zap.Reflect("adapter: ", adapter)) if err := adapter.Start(ctx); err != nil { logger.Fatal("failed to start adapter: ", zap.Error(err)) } } func newKubernetesClient() (kubernetes.Interface, error) { config, err := rest.InClusterConfig() if err != nil { return nil, fmt.Errorf("failed to create in-cluster config: %v", err) } return kubernetes.NewForConfig(config) } ================================================ FILE: rocketmq-knative/source/config/200-serviceaccount.yaml ================================================ # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # apiVersion: v1 kind: ServiceAccount metadata: name: rocketmqsource-controller-manager namespace: knative-sources ================================================ FILE: rocketmq-knative/source/config/201-clusterrole.yaml ================================================ # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRole metadata: name: eventing-sources-rocketmq-controller rules: - apiGroups: - sources.eventing.knative.dev resources: - rocketmqsources verbs: &everything - get - list - watch - create - update - patch - delete - apiGroups: - apps resources: - deployments verbs: *everything - apiGroups: - "" resources: - secrets verbs: &readOnly - get - list - watch - apiGroups: - eventing.knative.dev resources: - eventtypes verbs: *everything # Source statuses update - apiGroups: - sources.eventing.knative.dev resources: - rocketmqsources/status verbs: - get - update - patch ================================================ FILE: rocketmq-knative/source/config/202-clusterrolebinding.yaml ================================================ # Copyright 2019 The Knative Authors # # 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. apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: eventing-sources-rocketmq-controller subjects: - kind: ServiceAccount name: rocketmqsource-controller-manager namespace: knative-sources roleRef: apiGroup: rbac.authorization.k8s.io kind: ClusterRole name: eventing-sources-rocketmq-controller --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: eventing-sources-rocketmq-resolver subjects: - kind: ServiceAccount name: rocketmqsource-controller-manager namespace: knative-sources roleRef: apiGroup: rbac.authorization.k8s.io kind: ClusterRole name: addressable-resolver ================================================ FILE: rocketmq-knative/source/config/300-rocketmqsource.yaml ================================================ # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # apiVersion: apiextensions.k8s.io/v1beta1 kind: CustomResourceDefinition metadata: labels: eventing.knative.dev/source: "true" knative.dev/crd-install: "true" name: rocketmqsources.sources.eventing.knative.dev spec: group: sources.eventing.knative.dev names: categories: - all - knative - eventing - sources kind: RocketMQSource plural: rocketmqsources scope: Namespaced subresources: status: {} validation: openAPIV3Schema: properties: apiVersion: type: string kind: type: string metadata: type: object spec: properties: serviceAccountName: type: string description: "Name of the Kubernetes ServiceAccount that is running the Receiver Adapter Pods." sink: type: object description: "Reference to an object that will resolve to a domain name to use as the sink." transformer: type: object description: "Reference to an object that will resolve to a domain name to use as the transformer." tableName: type: string description: "ID of the topic to Subscribe to. It must be in the form of the unique identifier within the project, not the entire name. " instance: type: string description: "ID of the rocketmq instance to Subscribe to. It must be in the form of the unique identifier within the project, not the entire name. " type: object status: properties: conditions: items: properties: lastTransitionTime: # we use a string in the stored object but a wrapper object # at runtime. type: string message: type: string reason: type: string severity: type: string status: type: string type: type: string required: - type - status type: object type: array sinkUri: type: string transformerUri: type: string type: object version: v1alpha1 ================================================ FILE: rocketmq-knative/source/config/400-controller-service.yaml ================================================ # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # apiVersion: v1 kind: Service metadata: name: rocketmq-controller namespace: knative-sources labels: control-plane: rocketmqsource-controller-manager spec: selector: control-plane: rocketmqsource-controller-manager ports: - port: 443 ================================================ FILE: rocketmq-knative/source/config/500-controller.yaml ================================================ # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # apiVersion: apps/v1 kind: StatefulSet metadata: name: rocketmqsource-controller-manager namespace: knative-sources labels: control-plane: rocketmqsource-controller-manager spec: selector: matchLabels: &labels control-plane: rocketmqsource-controller-manager serviceName: rocketmqsource-controller-manager template: metadata: labels: *labels spec: serviceAccountName: rocketmqsource-controller-manager containers: - name: manager image: docker.io/apacherocketmq/rocketmqsource-controller:1.0.0 env: - name: RocketMQ_RA_IMAGE value: docker.io/apacherocketmq/rocketmqsource-adapter:1.0.0 serviceAccount: rocketmqsource-controller-manager terminationGracePeriodSeconds: 10 ================================================ FILE: rocketmq-knative/source/config/600-istioegress.yaml ================================================ # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You 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. # apiVersion: networking.istio.io/v1alpha3 kind: ServiceEntry metadata: name: rocketmq-ext spec: hosts: - "*.rocketmq.com" ports: - number: 443 name: https protocol: HTTPS - number: 9876 name: tcp-namesrv protocol: TCP - number: 10911 name: tcp-broker protocol: TCP ================================================ FILE: rocketmq-knative/source/pkg/adapter/adapter.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package rocketmq import ( "fmt" "encoding/json" "time" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" cloudevents "github.com/cloudevents/sdk-go" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/kncloudevents" "k8s.io/client-go/kubernetes" "golang.org/x/net/context" "github.com/apache/rocketmq-client-go" "github.com/apache/rocketmq-client-go/consumer" "github.com/apache/rocketmq-client-go/primitive" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis/sources/v1alpha1" ) type Adapter struct { K8sClient kubernetes.Interface Namespace string SecretName string SecretKey string Topic string NamesrvAddr string RNamespace string GroupName string SubscriptionID string SinkURI string AdCode string pushConsumer rocketmq.PushConsumer ceClient cloudevents.Client transformer bool transformerClient cloudevents.Client } func (a *Adapter) Start(ctx context.Context) error { var err error if a.ceClient == nil { if a.ceClient, err = kncloudevents.NewDefaultClient(a.SinkURI); err != nil { return fmt.Errorf("failed to create cloudevent client: %s", err.Error()) } } if(a.SecretName != "") { secret, err := a.K8sClient.CoreV1().Secrets(a.Namespace).Get(a.SecretName, v1.GetOptions{}) if err != nil { fmt.Errorf("Failed to get secret %s", err.Error()) return err } cred := &v1alpha1.Credentials{} err = json.Unmarshal(secret.Data[a.SecretKey], cred) if err != nil { fmt.Errorf("Failed to get secret %s", err.Error()) return err } a.pushConsumer, _ = rocketmq.NewPushConsumer( consumer.WithGroupName(a.GroupName), consumer.WithNameServer([] string {cred.Url}), consumer.WithCredentials(primitive.Credentials{ AccessKey: cred.AccessKeyId, SecretKey: cred.AccessKeySecret, }), consumer.WithNamespace(a.RNamespace), ) }else { a.pushConsumer, _ = rocketmq.NewPushConsumer( consumer.WithGroupName(a.GroupName), consumer.WithNameServer([] string {a.NamesrvAddr}), ) } return a.consumerStart() } func (a *Adapter) consumerStart() error { err := a.pushConsumer.Subscribe(a.Topic,consumer.MessageSelector{},a.receiveMsg) if err != nil { fmt.Println(err.Error()) } // Note: start after subscribe err = a.pushConsumer.Start() if err != nil { fmt.Println(err.Error()) return nil } for true { time.Sleep(time.Hour) } err = a.pushConsumer.Shutdown() if err != nil { fmt.Printf("shutdown Consumer error: %s", err.Error()) return nil } return err; } func (a *Adapter) receiveMsg(ctx context.Context, msgs ...*primitive.MessageExt) (consumer.ConsumeResult, error) { for i := range msgs { fmt.Printf("subscribe callback: %v \n", msgs[i]) event := cloudevents.NewEvent(cloudevents.VersionV02) event.SetID(msgs[i].MsgId) event.SetTime(time.Now()) event.SetDataContentType(*cloudevents.StringOfApplicationJSON()) event.SetSource("rocketmq") event.SetData(msgs[i]) event.SetType("RocketMQEventType") _, err := a.ceClient.Send(ctx, event) if err != nil { fmt.Println("error Send cloud event %s", err.Error()) } } return consumer.ConsumeSuccess, nil } ================================================ FILE: rocketmq-knative/source/pkg/apis/addtoscheme_eventing_v1alpha1.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package apis import ( eventingv1alpha1 "github.com/knative/eventing/pkg/apis/eventing/v1alpha1" ) func init() { // Register the types with the Scheme so the components can map objects to GroupVersionKinds and back AddToSchemes = append(AddToSchemes, eventingv1alpha1.SchemeBuilder.AddToScheme) } ================================================ FILE: rocketmq-knative/source/pkg/apis/addtoscheme_sources_v1alpha1.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package apis import ( "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis/sources/v1alpha1" ) func init() { // Register the types with the Scheme so the components can map objects to GroupVersionKinds and back AddToSchemes = append(AddToSchemes, v1alpha1.SchemeBuilder.AddToScheme) } ================================================ FILE: rocketmq-knative/source/pkg/apis/apis.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Generate deepcopy for apis //go:generate go run ../../vendor/k8s.io/code-generator/cmd/deepcopy-gen/main.go -O zz_generated.deepcopy -i ./... -h ../../hack/boilerplate.go.txt // Package apis contains Kubernetes API groups. package apis import ( "k8s.io/apimachinery/pkg/runtime" ) // AddToSchemes may be used to add all resources defined in the project to a Scheme var AddToSchemes runtime.SchemeBuilder // AddToScheme adds all Resources to the Scheme func AddToScheme(s *runtime.Scheme) error { return AddToSchemes.AddToScheme(s) } ================================================ FILE: rocketmq-knative/source/pkg/apis/sources/group.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Package sources contains sources API versions package sources ================================================ FILE: rocketmq-knative/source/pkg/apis/sources/v1alpha1/doc.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package v1alpha1 ================================================ FILE: rocketmq-knative/source/pkg/apis/sources/v1alpha1/register.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package v1alpha1 import ( "k8s.io/apimachinery/pkg/runtime/schema" "sigs.k8s.io/controller-runtime/pkg/runtime/scheme" ) var ( // SchemeGroupVersion is group version used to register these objects SchemeGroupVersion = schema.GroupVersion{Group: "sources.eventing.knative.dev", Version: "v1alpha1"} // SchemeBuilder is used to add go types to the GroupVersionKind scheme SchemeBuilder = &scheme.Builder{GroupVersion: SchemeGroupVersion} // AddToScheme is required by pkg/client/... AddToScheme = SchemeBuilder.AddToScheme ) // Resource is required by pkg/client/listers/... func Resource(resource string) schema.GroupResource { return SchemeGroupVersion.WithResource(resource).GroupResource() } ================================================ FILE: rocketmq-knative/source/pkg/apis/sources/v1alpha1/rocketmqsource_types.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package v1alpha1 import ( "fmt" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "knative.dev/pkg/apis/duck" duckv1alpha1 "knative.dev/pkg/apis/duck/v1alpha1" ) var _ runtime.Object = (*RocketMQSource)(nil) var _ = duck.VerifyType(&RocketMQSource{}, &duckv1alpha1.Conditions{}) const ( RocketMQSourceEventType = "apache.rocketmq" ) func RocketMQEventSource(topic string) string { return fmt.Sprintf("%s", topic) } const ( RocketMQConditionReady = duckv1alpha1.ConditionReady RocketMQConditionSinkProvided duckv1alpha1.ConditionType = "SinkProvided" RocketMQConditionTransformerProvided duckv1alpha1.ConditionType = "TransformerProvided" RocketMQConditionDeployed duckv1alpha1.ConditionType = "Deployed" RocketMQConditionSubscribed duckv1alpha1.ConditionType = "Subscribed" RocketMQConditionEventTypesProvided duckv1alpha1.ConditionType = "EventTypesProvided" ) var RocketMQSourceCondSet = duckv1alpha1.NewLivingConditionSet( RocketMQConditionSinkProvided, RocketMQConditionDeployed, RocketMQConditionSubscribed) type RocketMQSource struct { metav1.TypeMeta `json:",inline"` metav1.ObjectMeta `json:"metadata,omitempty"` Spec RocketMQSourceSpec `json:"spec,omitempty"` Status RocketMQSourceStatus `json:"status,omitempty"` } type RocketMQSourceList struct { metav1.TypeMeta `json:",inline"` metav1.ListMeta `json:"metadata,omitempty"` Items []RocketMQSource `json:"items"` } func init() { SchemeBuilder.Register(&RocketMQSource{}, &RocketMQSourceList{}) } type RocketMQSourceSpec struct { AccessToken SecretValueFromSource `json:"accessToken"` Topic string `json:"topic,omitempty"` NamesrvAddr string `json:"namesrvAddr,omitempty"` Namespace string `json:"namespace,omitempty"` GroupName string `json:"groupName,omitempty"` Sink *corev1.ObjectReference `json:"sink,omitempty"` ServiceAccountName string `json:"serviceAccountName,omitempty"` } type RocketMQSourceStatus struct { duckv1alpha1.Status `json:",inline"` SinkURI string `json:"sinkUri,omitempty"` } func (s *RocketMQSourceStatus) GetCondition(t duckv1alpha1.ConditionType) *duckv1alpha1.Condition { return RocketMQSourceCondSet.Manage(s).GetCondition(t) } // IsReady returns true if the resource is ready overall. func (s *RocketMQSourceStatus) IsReady() bool { return RocketMQSourceCondSet.Manage(s).IsHappy() } // InitializeConditions sets relevant unset conditions to Unknown state. func (s *RocketMQSourceStatus) InitializeConditions() { RocketMQSourceCondSet.Manage(s).InitializeConditions() } // MarkSink sets the condition that the source has a sink configured. func (s *RocketMQSourceStatus) MarkSink(uri string) { s.SinkURI = uri if len(uri) > 0 { RocketMQSourceCondSet.Manage(s).MarkTrue(RocketMQConditionSinkProvided) } else { RocketMQSourceCondSet.Manage(s).MarkUnknown(RocketMQConditionSinkProvided, "SinkEmpty", "Sink has resolved to empty.") } } func (s *RocketMQSourceStatus) MarkNoSink(reason, messageFormat string, messageA ...interface{}) { RocketMQSourceCondSet.Manage(s).MarkFalse(RocketMQConditionSinkProvided, reason, messageFormat, messageA...) } func (s *RocketMQSourceStatus) MarkNoTransformer(reason, messageFormat string, messageA ...interface{}) { RocketMQSourceCondSet.Manage(s).MarkFalse(RocketMQConditionTransformerProvided, reason, messageFormat, messageA...) } // MarkDeployed sets the condition that the source has been deployed. func (s *RocketMQSourceStatus) MarkDeployed() { RocketMQSourceCondSet.Manage(s).MarkTrue(RocketMQConditionDeployed) } // MarkDeploying sets the condition that the source is deploying. func (s *RocketMQSourceStatus) MarkDeploying(reason, messageFormat string, messageA ...interface{}) { RocketMQSourceCondSet.Manage(s).MarkUnknown(RocketMQConditionDeployed, reason, messageFormat, messageA...) } // MarkNotDeployed sets the condition that the source has not been deployed. func (s *RocketMQSourceStatus) MarkNotDeployed(reason, messageFormat string, messageA ...interface{}) { RocketMQSourceCondSet.Manage(s).MarkFalse(RocketMQConditionDeployed, reason, messageFormat, messageA...) } func (s *RocketMQSourceStatus) MarkSubscribed() { RocketMQSourceCondSet.Manage(s).MarkTrue(RocketMQConditionSubscribed) } // MarkEventTypes sets the condition that the source has created its event types. func (s *RocketMQSourceStatus) MarkEventTypes() { RocketMQSourceCondSet.Manage(s).MarkTrue(RocketMQConditionEventTypesProvided) } // MarkNoEventTypes sets the condition that the source does not its event types configured. func (s *RocketMQSourceStatus) MarkNoEventTypes(reason, messageFormat string, messageA ...interface{}) { RocketMQSourceCondSet.Manage(s).MarkFalse(RocketMQConditionEventTypesProvided, reason, messageFormat, messageA...) } // SecretValueFromSource represents the source of a secret value type SecretValueFromSource struct { // The Secret key to select from. SecretKeyRef *corev1.SecretKeySelector `json:"secretKeyRef,omitempty"` } type Credentials struct { Url string `json:"url"` AccessKeyId string `json:"accessKeyId"` AccessKeySecret string `json:"accessKeySecret"` } ================================================ FILE: rocketmq-knative/source/pkg/apis/sources/v1alpha1/zz_generated.deepcopy.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by main. DO NOT EDIT. package v1alpha1 import ( runtime "k8s.io/apimachinery/pkg/runtime" ) // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *RocketMQSource) DeepCopyInto(out *RocketMQSource) { *out = *in out.TypeMeta = in.TypeMeta in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) out.Spec = in.Spec out.Status = in.Status return } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RocketMQSource. func (in *RocketMQSource) DeepCopy() *RocketMQSource { if in == nil { return nil } out := new(RocketMQSource) in.DeepCopyInto(out) return out } // DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. func (in *RocketMQSource) DeepCopyObject() runtime.Object { if c := in.DeepCopy(); c != nil { return c } return nil } // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *RocketMQSourceList) DeepCopyInto(out *RocketMQSourceList) { *out = *in out.TypeMeta = in.TypeMeta out.ListMeta = in.ListMeta if in.Items != nil { in, out := &in.Items, &out.Items *out = make([]RocketMQSource, len(*in)) for i := range *in { (*in)[i].DeepCopyInto(&(*out)[i]) } } return } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RocketMQSourceList. func (in *RocketMQSourceList) DeepCopy() *RocketMQSourceList { if in == nil { return nil } out := new(RocketMQSourceList) in.DeepCopyInto(out) return out } // DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. func (in *RocketMQSourceList) DeepCopyObject() runtime.Object { if c := in.DeepCopy(); c != nil { return c } return nil } // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *RocketMQSourceSpec) DeepCopyInto(out *RocketMQSourceSpec) { *out = *in return } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RocketMQSourceSpec. func (in *RocketMQSourceSpec) DeepCopy() *RocketMQSourceSpec { if in == nil { return nil } out := new(RocketMQSourceSpec) in.DeepCopyInto(out) return out } // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *RocketMQSourceStatus) DeepCopyInto(out *RocketMQSourceStatus) { *out = *in return } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RocketMQSourceStatus. func (in *RocketMQSourceStatus) DeepCopy() *RocketMQSourceStatus { if in == nil { return nil } out := new(RocketMQSourceStatus) in.DeepCopyInto(out) return out } ================================================ FILE: rocketmq-knative/source/pkg/client/clientset/versioned/clientset.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by client-gen. DO NOT EDIT. package versioned import ( sourcesv1alpha1 "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/clientset/versioned/typed/sources/v1alpha1" discovery "k8s.io/client-go/discovery" rest "k8s.io/client-go/rest" flowcontrol "k8s.io/client-go/util/flowcontrol" ) type Interface interface { Discovery() discovery.DiscoveryInterface SourcesV1alpha1() sourcesv1alpha1.SourcesV1alpha1Interface // Deprecated: please explicitly pick a version if possible. Sources() sourcesv1alpha1.SourcesV1alpha1Interface } // Clientset contains the clients for groups. Each group has exactly one // version included in a Clientset. type Clientset struct { *discovery.DiscoveryClient sourcesV1alpha1 *sourcesv1alpha1.SourcesV1alpha1Client } // SourcesV1alpha1 retrieves the SourcesV1alpha1Client func (c *Clientset) SourcesV1alpha1() sourcesv1alpha1.SourcesV1alpha1Interface { return c.sourcesV1alpha1 } // Deprecated: Sources retrieves the default version of SourcesClient. // Please explicitly pick a version. func (c *Clientset) Sources() sourcesv1alpha1.SourcesV1alpha1Interface { return c.sourcesV1alpha1 } // Discovery retrieves the DiscoveryClient func (c *Clientset) Discovery() discovery.DiscoveryInterface { if c == nil { return nil } return c.DiscoveryClient } // NewForConfig creates a new Clientset for the given config. func NewForConfig(c *rest.Config) (*Clientset, error) { configShallowCopy := *c if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 { configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst) } var cs Clientset var err error cs.sourcesV1alpha1, err = sourcesv1alpha1.NewForConfig(&configShallowCopy) if err != nil { return nil, err } cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy) if err != nil { return nil, err } return &cs, nil } // NewForConfigOrDie creates a new Clientset for the given config and // panics if there is an error in the config. func NewForConfigOrDie(c *rest.Config) *Clientset { var cs Clientset cs.sourcesV1alpha1 = sourcesv1alpha1.NewForConfigOrDie(c) cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c) return &cs } // New creates a new Clientset for the given RESTClient. func New(c rest.Interface) *Clientset { var cs Clientset cs.sourcesV1alpha1 = sourcesv1alpha1.New(c) cs.DiscoveryClient = discovery.NewDiscoveryClient(c) return &cs } ================================================ FILE: rocketmq-knative/source/pkg/client/clientset/versioned/doc.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by client-gen. DO NOT EDIT. // This package has the automatically generated clientset. package versioned ================================================ FILE: rocketmq-knative/source/pkg/client/clientset/versioned/scheme/doc.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by client-gen. DO NOT EDIT. // This package contains the scheme of the automatically generated clientset. package scheme ================================================ FILE: rocketmq-knative/source/pkg/client/clientset/versioned/scheme/register.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by client-gen. DO NOT EDIT. package scheme import ( sourcesv1alpha1 "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis/sources/v1alpha1" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" runtime "k8s.io/apimachinery/pkg/runtime" schema "k8s.io/apimachinery/pkg/runtime/schema" serializer "k8s.io/apimachinery/pkg/runtime/serializer" utilruntime "k8s.io/apimachinery/pkg/util/runtime" ) var Scheme = runtime.NewScheme() var Codecs = serializer.NewCodecFactory(Scheme) var ParameterCodec = runtime.NewParameterCodec(Scheme) var localSchemeBuilder = runtime.SchemeBuilder{ sourcesv1alpha1.AddToScheme, } var AddToScheme = localSchemeBuilder.AddToScheme func init() { v1.AddToGroupVersion(Scheme, schema.GroupVersion{Version: "v1"}) utilruntime.Must(AddToScheme(Scheme)) } ================================================ FILE: rocketmq-knative/source/pkg/client/clientset/versioned/typed/sources/v1alpha1/doc.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by client-gen. DO NOT EDIT. // This package has the automatically generated typed clients. package v1alpha1 ================================================ FILE: rocketmq-knative/source/pkg/client/clientset/versioned/typed/sources/v1alpha1/generated_expansion.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by client-gen. DO NOT EDIT. package v1alpha1 type RocketMQSourceExpansion interface{} ================================================ FILE: rocketmq-knative/source/pkg/client/clientset/versioned/typed/sources/v1alpha1/rocketmqsource.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by client-gen. DO NOT EDIT. package v1alpha1 import ( "time" v1alpha1 "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis/sources/v1alpha1" scheme "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/clientset/versioned/scheme" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" types "k8s.io/apimachinery/pkg/types" watch "k8s.io/apimachinery/pkg/watch" rest "k8s.io/client-go/rest" ) // RocketMQSourcesGetter has a method to return a RocketMQSourceInterface. // A group's client should implement this interface. type RocketMQSourcesGetter interface { RocketMQSources(namespace string) RocketMQSourceInterface } // RocketMQSourceInterface has methods to work with RocketMQSource resources. type RocketMQSourceInterface interface { Create(source *v1alpha1.RocketMQSource) (*v1alpha1.RocketMQSource, error) Update(*v1alpha1.RocketMQSource) (*v1alpha1.RocketMQSource, error) UpdateStatus(*v1alpha1.RocketMQSource) (*v1alpha1.RocketMQSource, error) Delete(name string, options *v1.DeleteOptions) error DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error Get(name string, options v1.GetOptions) (*v1alpha1.RocketMQSource, error) List(opts v1.ListOptions) (*v1alpha1.RocketMQSourceList, error) Watch(opts v1.ListOptions) (watch.Interface, error) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.RocketMQSource, err error) RocketMQSourceExpansion } type rocketmqSources struct { client rest.Interface ns string } // newRocketMQSources returns a RocketMQSources func newRocketMQSources(c *SourcesV1alpha1Client, namespace string) *rocketmqSources { return &rocketmqSources{ client: c.RESTClient(), ns: namespace, } } // Get takes name of the rocketmqSource, and returns the corresponding rocketmqSource object, and an error if there is any. func (c *rocketmqSources) Get(name string, options v1.GetOptions) (result *v1alpha1.RocketMQSource, err error) { result = &v1alpha1.RocketMQSource{} err = c.client.Get(). Namespace(c.ns). Resource("rocketmqsources"). Name(name). VersionedParams(&options, scheme.ParameterCodec). Do(). Into(result) return } // List takes label and field selectors, and returns the list of RocketMQSources that match those selectors. func (c *rocketmqSources) List(opts v1.ListOptions) (result *v1alpha1.RocketMQSourceList, err error) { var timeout time.Duration if opts.TimeoutSeconds != nil { timeout = time.Duration(*opts.TimeoutSeconds) * time.Second } result = &v1alpha1.RocketMQSourceList{} err = c.client.Get(). Namespace(c.ns). Resource("rocketmqsources"). VersionedParams(&opts, scheme.ParameterCodec). Timeout(timeout). Do(). Into(result) return } // Watch rocketmqSources a watch.Interface that watches the requested rocketmqSources. func (c *rocketmqSources) Watch(opts v1.ListOptions) (watch.Interface, error) { var timeout time.Duration if opts.TimeoutSeconds != nil { timeout = time.Duration(*opts.TimeoutSeconds) * time.Second } opts.Watch = true return c.client.Get(). Namespace(c.ns). Resource("rocketmqsources"). VersionedParams(&opts, scheme.ParameterCodec). Timeout(timeout). Watch() } // Create takes the representation of a rocketmqSource and creates it. Returns the server's representation of the rocketmqSources, and an error, if there is any. func (c *rocketmqSources) Create(rocketmqSource *v1alpha1.RocketMQSource) (result *v1alpha1.RocketMQSource, err error) { result = &v1alpha1.RocketMQSource{} err = c.client.Post(). Namespace(c.ns). Resource("rocketmqsources"). Body(rocketmqSource). Do(). Into(result) return } // Update takes the representation of a rocketmqSources and updates it. Returns the server's representation of the rocketmqSources, and an error, if there is any. func (c *rocketmqSources) Update(rocketmqSource *v1alpha1.RocketMQSource) (result *v1alpha1.RocketMQSource, err error) { result = &v1alpha1.RocketMQSource{} err = c.client.Put(). Namespace(c.ns). Resource("rocketmqsources"). Name(rocketmqSource.Name). Body(rocketmqSource). Do(). Into(result) return } // UpdateStatus was generated because the type contains a Status member. // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). func (c *rocketmqSources) UpdateStatus(rocketmqSource *v1alpha1.RocketMQSource) (result *v1alpha1.RocketMQSource, err error) { result = &v1alpha1.RocketMQSource{} err = c.client.Put(). Namespace(c.ns). Resource("rocketmqsources"). Name(rocketmqSource.Name). SubResource("status"). Body(rocketmqSource). Do(). Into(result) return } // Delete takes name of the rocketmqsources and deletes it. Returns an error if one occurs. func (c *rocketmqSources) Delete(name string, options *v1.DeleteOptions) error { return c.client.Delete(). Namespace(c.ns). Resource("rocketmqsources"). Name(name). Body(options). Do(). Error() } // DeleteCollection deletes a collection of objects. func (c *rocketmqSources) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error { var timeout time.Duration if listOptions.TimeoutSeconds != nil { timeout = time.Duration(*listOptions.TimeoutSeconds) * time.Second } return c.client.Delete(). Namespace(c.ns). Resource("rocketmqsources"). VersionedParams(&listOptions, scheme.ParameterCodec). Timeout(timeout). Body(options). Do(). Error() } // Patch applies the patch and returns the patched rocketmqSources. func (c *rocketmqSources) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.rocketmqSources, err error) { result = &v1alpha1.rocketmqSources{} err = c.client.Patch(pt). Namespace(c.ns). Resource("rocketmqsources"). SubResource(subresources...). Name(name). Body(data). Do(). Into(result) return } ================================================ FILE: rocketmq-knative/source/pkg/client/clientset/versioned/typed/sources/v1alpha1/sources_client.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by client-gen. DO NOT EDIT. package v1alpha1 import ( v1alpha1 "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis/sources/v1alpha1" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/clientset/versioned/scheme" serializer "k8s.io/apimachinery/pkg/runtime/serializer" rest "k8s.io/client-go/rest" ) type SourcesV1alpha1Interface interface { RESTClient() rest.Interface RocketMQSourcesGetter } // SourcesV1alpha1Client is used to interact with features provided by the sources.knative.dev group. type SourcesV1alpha1Client struct { restClient rest.Interface } func (c *SourcesV1alpha1Client) RocketMQSources(namespace string) RocketMQSourceInterface { return newRocketMQSources(c, namespace) } // NewForConfig creates a new SourcesV1alpha1Client for the given config. func NewForConfig(c *rest.Config) (*SourcesV1alpha1Client, error) { config := *c if err := setConfigDefaults(&config); err != nil { return nil, err } client, err := rest.RESTClientFor(&config) if err != nil { return nil, err } return &SourcesV1alpha1Client{client}, nil } // NewForConfigOrDie creates a new SourcesV1alpha1Client for the given config and // panics if there is an error in the config. func NewForConfigOrDie(c *rest.Config) *SourcesV1alpha1Client { client, err := NewForConfig(c) if err != nil { panic(err) } return client } // New creates a new SourcesV1alpha1Client for the given RESTClient. func New(c rest.Interface) *SourcesV1alpha1Client { return &SourcesV1alpha1Client{c} } func setConfigDefaults(config *rest.Config) error { gv := v1alpha1.SchemeGroupVersion config.GroupVersion = &gv config.APIPath = "/apis" config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs} if config.UserAgent == "" { config.UserAgent = rest.DefaultKubernetesUserAgent() } return nil } // RESTClient returns a RESTClient that is used to communicate // with API server by this client implementation. func (c *SourcesV1alpha1Client) RESTClient() rest.Interface { if c == nil { return nil } return c.restClient } ================================================ FILE: rocketmq-knative/source/pkg/client/informers/externalversions/factory.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by informer-gen. DO NOT EDIT. package externalversions import ( reflect "reflect" sync "sync" time "time" versioned "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/clientset/versioned" internalinterfaces "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/informers/externalversions/internalinterfaces" sources "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/informers/externalversions/sources" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" runtime "k8s.io/apimachinery/pkg/runtime" schema "k8s.io/apimachinery/pkg/runtime/schema" cache "k8s.io/client-go/tools/cache" ) // SharedInformerOption defines the functional option type for SharedInformerFactory. type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory type sharedInformerFactory struct { client versioned.Interface namespace string tweakListOptions internalinterfaces.TweakListOptionsFunc lock sync.Mutex defaultResync time.Duration customResync map[reflect.Type]time.Duration informers map[reflect.Type]cache.SharedIndexInformer // startedInformers is used for tracking which informers have been started. // This allows Start() to be called multiple times safely. startedInformers map[reflect.Type]bool } // WithCustomResyncConfig sets a custom resync period for the specified informer types. func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption { return func(factory *sharedInformerFactory) *sharedInformerFactory { for k, v := range resyncConfig { factory.customResync[reflect.TypeOf(k)] = v } return factory } } // WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory. func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption { return func(factory *sharedInformerFactory) *sharedInformerFactory { factory.tweakListOptions = tweakListOptions return factory } } // WithNamespace limits the SharedInformerFactory to the specified namespace. func WithNamespace(namespace string) SharedInformerOption { return func(factory *sharedInformerFactory) *sharedInformerFactory { factory.namespace = namespace return factory } } // NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces. func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory { return NewSharedInformerFactoryWithOptions(client, defaultResync) } // NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory. // Listers obtained via this SharedInformerFactory will be subject to the same filters // as specified here. // Deprecated: Please use NewSharedInformerFactoryWithOptions instead func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory { return NewSharedInformerFactoryWithOptions(client, defaultResync, WithNamespace(namespace), WithTweakListOptions(tweakListOptions)) } // NewSharedInformerFactoryWithOptions constructs a new instance of a SharedInformerFactory with additional options. func NewSharedInformerFactoryWithOptions(client versioned.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory { factory := &sharedInformerFactory{ client: client, namespace: v1.NamespaceAll, defaultResync: defaultResync, informers: make(map[reflect.Type]cache.SharedIndexInformer), startedInformers: make(map[reflect.Type]bool), customResync: make(map[reflect.Type]time.Duration), } // Apply all options for _, opt := range options { factory = opt(factory) } return factory } // Start initializes all requested informers. func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) { f.lock.Lock() defer f.lock.Unlock() for informerType, informer := range f.informers { if !f.startedInformers[informerType] { go informer.Run(stopCh) f.startedInformers[informerType] = true } } } // WaitForCacheSync waits for all started informers' cache were synced. func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool { informers := func() map[reflect.Type]cache.SharedIndexInformer { f.lock.Lock() defer f.lock.Unlock() informers := map[reflect.Type]cache.SharedIndexInformer{} for informerType, informer := range f.informers { if f.startedInformers[informerType] { informers[informerType] = informer } } return informers }() res := map[reflect.Type]bool{} for informType, informer := range informers { res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced) } return res } // InternalInformerFor returns the SharedIndexInformer for obj using an internal // client. func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer { f.lock.Lock() defer f.lock.Unlock() informerType := reflect.TypeOf(obj) informer, exists := f.informers[informerType] if exists { return informer } resyncPeriod, exists := f.customResync[informerType] if !exists { resyncPeriod = f.defaultResync } informer = newFunc(f.client, resyncPeriod) f.informers[informerType] = informer return informer } // SharedInformerFactory provides shared informers for resources in all known // API group versions. type SharedInformerFactory interface { internalinterfaces.SharedInformerFactory ForResource(resource schema.GroupVersionResource) (GenericInformer, error) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool Sources() sources.Interface } func (f *sharedInformerFactory) Sources() sources.Interface { return sources.New(f, f.namespace, f.tweakListOptions) } ================================================ FILE: rocketmq-knative/source/pkg/client/informers/externalversions/generic.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by informer-gen. DO NOT EDIT. package externalversions import ( "fmt" v1alpha1 "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis/sources/v1alpha1" schema "k8s.io/apimachinery/pkg/runtime/schema" cache "k8s.io/client-go/tools/cache" ) // GenericInformer is type of SharedIndexInformer which will locate and delegate to other // sharedInformers based on type type GenericInformer interface { Informer() cache.SharedIndexInformer Lister() cache.GenericLister } type genericInformer struct { informer cache.SharedIndexInformer resource schema.GroupResource } // Informer returns the SharedIndexInformer. func (f *genericInformer) Informer() cache.SharedIndexInformer { return f.informer } // Lister returns the GenericLister. func (f *genericInformer) Lister() cache.GenericLister { return cache.NewGenericLister(f.Informer().GetIndexer(), f.resource) } // ForResource gives generic access to a shared informer of the matching type // TODO extend this to unknown resources with a client pool func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) { switch resource { // Group=sources.eventing.knative.dev, Version=v1alpha1 case v1alpha1.SchemeGroupVersion.WithResource("rocketmqsources"): return &genericInformer{resource: resource.GroupResource(), informer: f.Sources().V1alpha1().RocketMQSources().Informer()}, nil } return nil, fmt.Errorf("no informer found for %v", resource) } ================================================ FILE: rocketmq-knative/source/pkg/client/informers/externalversions/internalinterfaces/factory_interfaces.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by informer-gen. DO NOT EDIT. package internalinterfaces import ( time "time" versioned "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/clientset/versioned" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" runtime "k8s.io/apimachinery/pkg/runtime" cache "k8s.io/client-go/tools/cache" ) // NewInformerFunc takes versioned.Interface and time.Duration to return a SharedIndexInformer. type NewInformerFunc func(versioned.Interface, time.Duration) cache.SharedIndexInformer // SharedInformerFactory a small interface to allow for adding an informer without an import cycle type SharedInformerFactory interface { Start(stopCh <-chan struct{}) InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer } // TweakListOptionsFunc is a function that transforms a v1.ListOptions. type TweakListOptionsFunc func(*v1.ListOptions) ================================================ FILE: rocketmq-knative/source/pkg/client/informers/externalversions/sources/interface.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by informer-gen. DO NOT EDIT. package sources import ( internalinterfaces "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/informers/externalversions/internalinterfaces" v1alpha1 "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/informers/externalversions/sources/v1alpha1" ) // Interface provides access to each of this group's versions. type Interface interface { // V1alpha1 provides access to shared informers for resources in V1alpha1. V1alpha1() v1alpha1.Interface } type group struct { factory internalinterfaces.SharedInformerFactory namespace string tweakListOptions internalinterfaces.TweakListOptionsFunc } // New returns a new Interface. func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface { return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions} } // V1alpha1 returns a new v1alpha1.Interface. func (g *group) V1alpha1() v1alpha1.Interface { return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions) } ================================================ FILE: rocketmq-knative/source/pkg/client/informers/externalversions/sources/v1alpha1/interface.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by informer-gen. DO NOT EDIT. package v1alpha1 import ( internalinterfaces "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/informers/externalversions/internalinterfaces" ) // Interface provides access to all the informers in this group version. type Interface interface { RocketMQSources() RocketMQSourceInformer } type version struct { factory internalinterfaces.SharedInformerFactory namespace string tweakListOptions internalinterfaces.TweakListOptionsFunc } // New returns a new Interface. func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface { return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions} } func (v *version) RocketMQSources() RocketMQSourceInformer { return &rocketmqSourceInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions} } ================================================ FILE: rocketmq-knative/source/pkg/client/informers/externalversions/sources/v1alpha1/rocketmqsource.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by informer-gen. DO NOT EDIT. package v1alpha1 import ( time "time" sourcesv1alpha1 "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis/sources/v1alpha1" versioned "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/clientset/versioned" internalinterfaces "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/informers/externalversions/internalinterfaces" v1alpha1 "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/client/listers/sources/v1alpha1" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" runtime "k8s.io/apimachinery/pkg/runtime" watch "k8s.io/apimachinery/pkg/watch" cache "k8s.io/client-go/tools/cache" ) type RocketMQSourceInformer interface { Informer() cache.SharedIndexInformer Lister() v1alpha1.RocketMQSourceLister } type rocketmqSourceInformer struct { factory internalinterfaces.SharedInformerFactory tweakListOptions internalinterfaces.TweakListOptionsFunc namespace string } // NewRocketMQSourceInformer constructs a new informer for RocketMQSource type. // Always prefer using an informer factory to get a shared informer instead of getting an independent // one. This reduces memory footprint and number of connections to the server. func NewRocketMQSourceInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { return NewFilteredRocketMQSourceInformer(client, namespace, resyncPeriod, indexers, nil) } // NewFilteredRocketMQSourceInformer constructs a new informer for RocketMQSource type. // Always prefer using an informer factory to get a shared informer instead of getting an independent // one. This reduces memory footprint and number of connections to the server. func NewFilteredRocketMQSourceInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { return cache.NewSharedIndexInformer( &cache.ListWatch{ ListFunc: func(options v1.ListOptions) (runtime.Object, error) { if tweakListOptions != nil { tweakListOptions(&options) } return client.SourcesV1alpha1().RocketMQSources(namespace).List(options) }, WatchFunc: func(options v1.ListOptions) (watch.Interface, error) { if tweakListOptions != nil { tweakListOptions(&options) } return client.SourcesV1alpha1().RocketMQSources(namespace).Watch(options) }, }, &sourcesv1alpha1.RocketMQSource{}, resyncPeriod, indexers, ) } func (f *rocketmqSourceInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { return NewFilteredRocketMQSourceInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) } func (f *rocketmqSourceInformer) Informer() cache.SharedIndexInformer { return f.factory.InformerFor(&sourcesv1alpha1.RocketMQSource{}, f.defaultInformer) } func (f *rocketmqSourceInformer) Lister() v1alpha1.RocketMQSourceLister { return v1alpha1.NewRocketMQSourceLister(f.Informer().GetIndexer()) } ================================================ FILE: rocketmq-knative/source/pkg/client/listers/sources/v1alpha1/expansion_generated.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by lister-gen. DO NOT EDIT. package v1alpha1 type RocketMQSourceListerExpansion interface{} type RocketMQSourceNamespaceListerExpansion interface{} ================================================ FILE: rocketmq-knative/source/pkg/client/listers/sources/v1alpha1/rocketmqsource.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ // Code generated by lister-gen. DO NOT EDIT. package v1alpha1 import ( v1alpha1 "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis/sources/v1alpha1" "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/labels" "k8s.io/client-go/tools/cache" ) // RocketMQSourceLister helps list RocketMQSource. type RocketMQSourceLister interface { // List lists all RocketMQSources in the indexer. List(selector labels.Selector) (ret []*v1alpha1.RocketMQSource, err error) // RocketMQSources returns an object that can list and get RocketMQSources. RocketMQSources(namespace string) RocketMQSourceNamespaceLister RocketMQSourceListerExpansion } // rocketmqSourceLister implements the RocketMQSourceLister interface. type rocketmqsourceSourceLister struct { indexer cache.Indexer } // NewRocketMQSourceLister returns a new RocketMQSourceLister. func NewRocketMQSourceLister(indexer cache.Indexer) RocketMQSourceLister { return &rocketmqsourceSourceLister{indexer: indexer} } // List lists all RocketMQSources in the indexer. func (s *rocketmqsourceSourceLister) List(selector labels.Selector) (ret []*v1alpha1.RocketMQSource, err error) { err = cache.ListAll(s.indexer, selector, func(m interface{}) { ret = append(ret, m.(*v1alpha1.RocketMQSource)) }) return ret, err } // RocketMQSources returns an object that can list and get RocketMQSources. func (s *rocketmqsourceSourceLister) RocketMQSources(namespace string) RocketMQSourceNamespaceLister { return rocketmqSourceNamespaceLister{indexer: s.indexer, namespace: namespace} } // RocketMQSourceNamespaceLister helps list and get RocketMQSources. type RocketMQSourceNamespaceLister interface { // List lists all RocketMQSources in the indexer for a given namespace. List(selector labels.Selector) (ret []*v1alpha1.RocketMQSource, err error) // Get retrieves the RocketMQSource from the indexer for a given namespace and name. Get(name string) (*v1alpha1.RocketMQSource, error) RocketMQSourceNamespaceListerExpansion } // rocketmqSourceNamespaceLister implements the RocketMQSourceNamespaceLister // interface. type rocketmqSourceNamespaceLister struct { indexer cache.Indexer namespace string } // List lists all RocketMQSources in the indexer for a given namespace. func (s rocketmqSourceNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.RocketMQSource, err error) { err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) { ret = append(ret, m.(*v1alpha1.RocketMQSource)) }) return ret, err } // Get retrieves the RocketMQSource from the indexer for a given namespace and name. func (s rocketmqSourceNamespaceLister) Get(name string) (*v1alpha1.RocketMQSource, error) { obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name) if err != nil { return nil, err } if !exists { return nil, errors.NewNotFound(v1alpha1.Resource("rocketmqsource"), name) } return obj.(*v1alpha1.RocketMQSource), nil } ================================================ FILE: rocketmq-knative/source/pkg/controller/sdk/finalizers_accessor.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package sdk import ( "errors" "fmt" "reflect" "k8s.io/apimachinery/pkg/util/sets" ) // FinalizersAccessor is the interface for a Resource that implements the getter and setting for // accessing its Finalizer set. // +k8s:deepcopy-gen=true type FinalizersAccessor interface { GetFinalizers() sets.String SetFinalizers(finalizers sets.String) } // NewReflectedFinalizersAccessor uses reflection to return a FinalizersAccessor to access the field // called "Finalizers". func NewReflectedFinalizersAccessor(object interface{}) (FinalizersAccessor, error) { objectValue := reflect.Indirect(reflect.ValueOf(object)) // If object is not a struct, don't even try to use it. if objectValue.Kind() != reflect.Struct { return nil, errors.New("object is not a struct") } finalizersField := objectValue.FieldByName("Finalizers") if finalizersField.IsValid() && finalizersField.CanSet() && finalizersField.Kind() == reflect.Slice { finalizers := sets.NewString() for i := 0; i < finalizersField.Len(); i++ { finalizer := finalizersField.Index(i) if finalizer.IsValid() && finalizer.Kind() == reflect.String { finalizers.Insert(finalizer.String()) } else { return nil, fmt.Errorf("element in the Finalizer slice was not a string: %v", finalizer.Kind()) } } return &reflectedFinalizersAccessor{ finalizersField: finalizersField, finalizersSet: finalizers, }, nil } return nil, fmt.Errorf("finalizer was not a slice: %v", finalizersField.Kind()) } // reflectedFinalizersAccessor is an internal wrapper object to act as the FinalizersAccessor for // objects that do not implement FinalizersAccessor directly, but do expose the field using the // name "Finalizers". type reflectedFinalizersAccessor struct { finalizersField reflect.Value finalizersSet sets.String } // GetFinalizers uses reflection to return the Finalizers set from the held object. func (r *reflectedFinalizersAccessor) GetFinalizers() sets.String { return r.finalizersSet } // SetFinalizers uses reflection to set Finalizers on the held object. func (r *reflectedFinalizersAccessor) SetFinalizers(finalizers sets.String) { r.finalizersSet = finalizers r.finalizersField.Set(reflect.ValueOf(finalizers.List())) } ================================================ FILE: rocketmq-knative/source/pkg/controller/sdk/provider.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package sdk import ( "context" "go.uber.org/zap" "k8s.io/apimachinery/pkg/runtime" "sigs.k8s.io/controller-runtime/pkg/controller" "sigs.k8s.io/controller-runtime/pkg/handler" "sigs.k8s.io/controller-runtime/pkg/manager" "sigs.k8s.io/controller-runtime/pkg/runtime/inject" "sigs.k8s.io/controller-runtime/pkg/source" ) type KnativeReconciler interface { Reconcile(ctx context.Context, object runtime.Object) error inject.Client } type Provider struct { AgentName string // Parent is a resource kind to reconcile with empty content. i.e. &v1.Parent{} Parent runtime.Object // Owns are dependent resources owned by the parent for which changes to // those resources cause the Parent to be re-reconciled. This is a list of // resources of kind with empty content. i.e. [&v1.Child{}] Owns []runtime.Object Reconciler KnativeReconciler } // ProvideController returns a controller for controller-runtime. func (p *Provider) Add(mgr manager.Manager, logger *zap.SugaredLogger) error { // Setup a new controller to Reconcile Subscriptions. c, err := controller.New(p.AgentName, mgr, controller.Options{ Reconciler: &Reconciler{ provider: *p, recorder: mgr.GetRecorder(p.AgentName), logger: *logger, }, }) if err != nil { return err } // Watch Parent events and enqueue Parent object key. if err := c.Watch(&source.Kind{Type: p.Parent}, &handler.EnqueueRequestForObject{}); err != nil { return err } // Watch and enqueue for owning obj key. for _, t := range p.Owns { if err := c.Watch(&source.Kind{Type: t}, &handler.EnqueueRequestForOwner{OwnerType: p.Parent, IsController: true}); err != nil { return err } } return nil } ================================================ FILE: rocketmq-knative/source/pkg/controller/sdk/reconciler.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package sdk import ( "context" "go.uber.org/zap" "k8s.io/apimachinery/pkg/api/equality" "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/runtime" "k8s.io/client-go/rest" "k8s.io/client-go/tools/record" "knative.dev/pkg/logging" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/reconcile" "sigs.k8s.io/controller-runtime/pkg/runtime/inject" ) type Reconciler struct { client client.Client recorder record.EventRecorder scheme *runtime.Scheme logger zap.SugaredLogger provider Provider } // Verify the struct implements reconcile.Reconciler var _ reconcile.Reconciler = &Reconciler{} // Reconcile compares the actual state with the desired, and attempts to // converge the two. func (r *Reconciler) Reconcile(request reconcile.Request) (reconcile.Result, error) { ctx := logging.WithLogger(context.TODO(), r.logger.With(zap.Any("request", request))) logger := logging.FromContext(ctx) logger.Infof("Reconciling %s %v", r.provider.Parent.GetObjectKind(), request) original := r.provider.Parent.DeepCopyObject() err := r.client.Get(context.TODO(), request.NamespacedName, original) if errors.IsNotFound(err) { logger.Errorf("could not find %s %v\n", r.provider.Parent.GetObjectKind(), request) return reconcile.Result{}, nil } if err != nil { logger.Errorf("could not fetch %s %v for %+v\n", r.provider.Parent.GetObjectKind(), err, request) return reconcile.Result{}, err } // Don't modify the cache's copy obj := original.DeepCopyObject() // Reconcile this copy of the Source and then write back any status // updates regardless of whether the reconcile error out. reconcileErr := r.provider.Reconciler.Reconcile(ctx, obj) if reconcileErr != nil { logger.Warnf("Failed to reconcile %s: %v", r.provider.Parent.GetObjectKind(), reconcileErr) } if needsUpdate, err := r.needsUpdate(ctx, original, obj); err != nil { logger.Desugar().Error("Unable to determine if an update is needed", zap.Error(err), zap.Any("original", original), zap.Any("obj", obj)) return reconcile.Result{}, err } else if needsUpdate { if _, err := r.update(ctx, request, obj); err != nil { logger.Desugar().Error("Failed to update", zap.Error(err), zap.Any("objectKind", r.provider.Parent.GetObjectKind())) return reconcile.Result{}, err } } // Requeue if the resource is not ready: return reconcile.Result{}, reconcileErr } func (r *Reconciler) InjectClient(c client.Client) error { r.client = c _, err := inject.ClientInto(c, r.provider.Reconciler) return err } func (r *Reconciler) InjectConfig(c *rest.Config) error { _, err := inject.ConfigInto(c, r.provider.Reconciler) return err } func (r *Reconciler) needsUpdate(ctx context.Context, old, new runtime.Object) (bool, error) { if old == nil { return true, nil } // Check Status. os, err := NewReflectedStatusAccessor(old) if err != nil { return false, err } ns, err := NewReflectedStatusAccessor(new) if err != nil { return false, err } oStatus := os.GetStatus() nStatus := ns.GetStatus() if !equality.Semantic.DeepEqual(oStatus, nStatus) { return true, nil } // Check finalizers. of, err := NewReflectedFinalizersAccessor(old) if err != nil { return false, err } nf, err := NewReflectedFinalizersAccessor(new) if err != nil { return false, err } oFinalizers := of.GetFinalizers() nFinalizers := nf.GetFinalizers() if !equality.Semantic.DeepEqual(oFinalizers, nFinalizers) { return true, nil } return false, nil } func (r *Reconciler) update(ctx context.Context, request reconcile.Request, object runtime.Object) (runtime.Object, error) { freshObj := r.provider.Parent.DeepCopyObject() if err := r.client.Get(ctx, request.NamespacedName, freshObj); err != nil { return nil, err } // Finalizers freshFinalizers, err := NewReflectedFinalizersAccessor(freshObj) if err != nil { return nil, err } orgFinalizers, err := NewReflectedFinalizersAccessor(object) if err != nil { return nil, err } freshFinalizers.SetFinalizers(orgFinalizers.GetFinalizers()) if err := r.client.Update(ctx, freshObj); err != nil { return nil, err } // Refetch freshObj = r.provider.Parent.DeepCopyObject() if err := r.client.Get(ctx, request.NamespacedName, freshObj); err != nil { return nil, err } // Status freshStatus, err := NewReflectedStatusAccessor(freshObj) if err != nil { return nil, err } orgStatus, err := NewReflectedStatusAccessor(object) if err != nil { return nil, err } freshStatus.SetStatus(orgStatus.GetStatus()) if err := r.client.Status().Update(ctx, freshObj); err != nil { return nil, err } return freshObj, nil } ================================================ FILE: rocketmq-knative/source/pkg/controller/sdk/status_accessor.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package sdk import ( "errors" "fmt" "reflect" ) // StatusAccessor is the interface for a Resource that implements the getter and // setter for accessing a Condition collection. // +k8s:deepcopy-gen=true type StatusAccessor interface { GetStatus() interface{} SetStatus(interface{}) } // NewReflectedStatusAccessor uses reflection to return a StatusAccessor // to access the field called "Status". func NewReflectedStatusAccessor(object interface{}) (StatusAccessor, error) { objectValue := reflect.Indirect(reflect.ValueOf(object)) // If object is not a struct, don't even try to use it. if objectValue.Kind() != reflect.Struct { return nil, errors.New("object is not a struct") } statusField := objectValue.FieldByName("Status") if statusField.IsValid() && statusField.CanInterface() && statusField.CanSet() { if _, ok := statusField.Interface().(interface{}); ok { return &reflectedStatusAccessor{ status: statusField, }, nil } } return nil, fmt.Errorf("status was not an interface: %v", statusField.Kind()) } // reflectedConditionsAccessor is an internal wrapper object to act as the // ConditionsAccessor for status objects that do not implement ConditionsAccessor // directly, but do expose the field using the "Conditions" field name. type reflectedStatusAccessor struct { status reflect.Value } // GetConditions uses reflection to return Conditions from the held status object. func (r *reflectedStatusAccessor) GetStatus() interface{} { if r != nil && r.status.IsValid() && r.status.CanInterface() { if status, ok := r.status.Interface().(interface{}); ok { return status } } return nil } // SetConditions uses reflection to set Conditions on the held status object. func (r *reflectedStatusAccessor) SetStatus(status interface{}) { if r != nil && r.status.IsValid() && r.status.CanSet() { r.status.Set(reflect.ValueOf(status)) } } ================================================ FILE: rocketmq-knative/source/pkg/controller/sinks/sinks.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package sinks import ( "context" "fmt" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "knative.dev/pkg/apis/duck" duckv1alpha1 "knative.dev/pkg/apis/duck/v1alpha1" "sigs.k8s.io/controller-runtime/pkg/client" ) // GetSinkURI retrieves the sink URI from the object referenced by the given // ObjectReference. func GetSinkURI(ctx context.Context, c client.Client, sink *corev1.ObjectReference, namespace string) (string, error) { if sink == nil { return "", fmt.Errorf("sink ref is nil") } u := &unstructured.Unstructured{} u.SetGroupVersionKind(sink.GroupVersionKind()) err := c.Get(ctx, client.ObjectKey{Namespace: namespace, Name: sink.Name}, u) if err != nil { return "", err } objIdentifier := fmt.Sprintf("\"%s/%s\" (%s)", u.GetNamespace(), u.GetName(), u.GroupVersionKind()) // Special case v1/Service to allow it be addressable if u.GroupVersionKind().Kind == "Service" && u.GroupVersionKind().Version == "v1" { return fmt.Sprintf("http://%s.%s.svc/", u.GetName(), u.GetNamespace()), nil } t := duckv1alpha1.AddressableType{} err = duck.FromUnstructured(u, &t) if err != nil { return "", fmt.Errorf("failed to deserialize sink %s: %v", objIdentifier, err) } if t.Status.Address == nil { return "", fmt.Errorf("sink %s does not contain address", objIdentifier) } url := t.Status.Address.GetURL() if url.Host == "" { return "", fmt.Errorf("sink %s contains an empty hostname", objIdentifier) } return url.String(), nil } ================================================ FILE: rocketmq-knative/source/pkg/controller/sinks/sinks_test.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package sinks import ( "context" "fmt" "testing" "github.com/google/go-cmp/cmp" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime" "k8s.io/client-go/kubernetes/scheme" duckv1alpha1 "knative.dev/pkg/apis/duck/v1alpha1" "sigs.k8s.io/controller-runtime/pkg/client/fake" ) var ( addressableDNS = "addressable.sink.svc.cluster.local" addressableURL = fmt.Sprintf("http://%s", addressableDNS) addressableName = "testsink" addressableKind = "Sink" addressableAPIVersion = "duck.knative.dev/v1alpha1" serviceName = "test-service" serviceKind = "Service" serviceAPIVersion = "v1" serviceDNSName = "http://test-service.testnamespace.svc/" unaddressableName = "testunaddressable" unaddressableKind = "KResource" unaddressableAPIVersion = "duck.knative.dev/v1alpha1" unaddressableResource = "kresources.duck.knative.dev" testNS = "testnamespace" ) func init() { // Add types to scheme _ = duckv1alpha1.AddToScheme(scheme.Scheme) } func TestGetSinkURI(t *testing.T) { testCases := map[string]struct { objects []runtime.Object namespace string want string wantErr error ref *corev1.ObjectReference }{ "happy - hostname": { objects: []runtime.Object{ getAddressableWithHostname(), }, namespace: testNS, ref: getAddressableRef(), want: addressableURL, }, "happy - uri": { objects: []runtime.Object{ getAddressable(), }, namespace: testNS, ref: getAddressableRef(), want: addressableURL, }, "nil hostname": { objects: []runtime.Object{ getAddressableNilHostname(), }, namespace: testNS, ref: getUnaddressableRef(), wantErr: fmt.Errorf(`sink "testnamespace/testunaddressable" (duck.knative.dev/v1alpha1, Kind=KResource) contains an empty hostname`), }, "nil sink": { objects: []runtime.Object{ getAddressableNilHostname(), }, namespace: testNS, ref: nil, wantErr: fmt.Errorf(`sink ref is nil`), }, "v1Service": { objects: []runtime.Object{ v1Service(), }, namespace: testNS, ref: getServiceRef(), want: serviceDNSName, }, "nil address": { objects: []runtime.Object{ getAddressableNilAddress(), }, namespace: testNS, ref: nil, wantErr: fmt.Errorf(`sink ref is nil`), }, "notSink": { objects: []runtime.Object{ getAddressableNoStatus(), }, namespace: testNS, ref: getUnaddressableRef(), wantErr: fmt.Errorf(`sink "testnamespace/testunaddressable" (duck.knative.dev/v1alpha1, Kind=KResource) does not contain address`), }, "notFound": { namespace: testNS, ref: getUnaddressableRef(), wantErr: fmt.Errorf(`%s "%s" not found`, unaddressableResource, unaddressableName), }, } for n, tc := range testCases { t.Run(n, func(t *testing.T) { ctx := context.Background() client := fake.NewFakeClient(tc.objects...) uri, gotErr := GetSinkURI(ctx, client, tc.ref, tc.namespace) if gotErr != nil { if tc.wantErr != nil { if diff := cmp.Diff(tc.wantErr.Error(), gotErr.Error()); diff != "" { t.Errorf("%s: unexpected error (-want, +got) = %v", n, diff) } } else { t.Errorf("%s: unexpected error %v", n, gotErr.Error()) } } if gotErr == nil { got := uri if diff := cmp.Diff(tc.want, got); diff != "" { t.Errorf("%s: unexpected object (-want, +got) = %v", n, diff) } } }) } } func v1Service() *unstructured.Unstructured { return &unstructured.Unstructured{ Object: map[string]interface{}{ "apiVersion": serviceAPIVersion, "kind": serviceKind, "metadata": map[string]interface{}{ "namespace": testNS, "name": serviceName, }, }, } } func getAddressable() *unstructured.Unstructured { return &unstructured.Unstructured{ Object: map[string]interface{}{ "apiVersion": addressableAPIVersion, "kind": addressableKind, "metadata": map[string]interface{}{ "namespace": testNS, "name": addressableName, }, "status": map[string]interface{}{ "address": map[string]interface{}{ "url": addressableURL, }, }, }, } } func getAddressableWithHostname() *unstructured.Unstructured { a := getAddressable() a.Object["status"] = map[string]interface{}{ "address": map[string]interface{}{ "hostname": addressableDNS, }, } return a } func getAddressableNoStatus() *unstructured.Unstructured { return &unstructured.Unstructured{ Object: map[string]interface{}{ "apiVersion": unaddressableAPIVersion, "kind": unaddressableKind, "metadata": map[string]interface{}{ "namespace": testNS, "name": unaddressableName, }, }, } } func getAddressableNilAddress() *unstructured.Unstructured { return &unstructured.Unstructured{ Object: map[string]interface{}{ "apiVersion": unaddressableAPIVersion, "kind": unaddressableKind, "metadata": map[string]interface{}{ "namespace": testNS, "name": unaddressableName, }, "status": map[string]interface{}{ "address": map[string]interface{}(nil), }, }, } } func getAddressableNilHostname() *unstructured.Unstructured { return &unstructured.Unstructured{ Object: map[string]interface{}{ "apiVersion": unaddressableAPIVersion, "kind": unaddressableKind, "metadata": map[string]interface{}{ "namespace": testNS, "name": unaddressableName, }, "status": map[string]interface{}{ "address": map[string]interface{}{ "hostname": nil, }, }, }, } } func getServiceRef() *corev1.ObjectReference { return &corev1.ObjectReference{ Kind: serviceKind, Name: serviceName, APIVersion: serviceAPIVersion, } } func getAddressableRef() *corev1.ObjectReference { return &corev1.ObjectReference{ Kind: addressableKind, Name: addressableName, APIVersion: addressableAPIVersion, } } func getUnaddressableRef() *corev1.ObjectReference { return &corev1.ObjectReference{ Kind: unaddressableKind, Name: unaddressableName, APIVersion: unaddressableAPIVersion, } } ================================================ FILE: rocketmq-knative/source/pkg/controller/testing/mock_client.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package testing import ( "context" "k8s.io/apimachinery/pkg/runtime" "sigs.k8s.io/controller-runtime/pkg/client" ) type MockHandled int const ( // This mock has handled the function call, no further mocks nor the real client should be // called. Handled MockHandled = iota // This mock has not handled the function call, subsequent mocks or the real client should be // called. Unhandled ) // All of the funcions in client.Client get mocked equivalents. For the function // client.Client.Foo(), the mocked equivalent will be: // func(innerClient client.Client[, arguments to Foo()]) (MockHandled[, returns from Foo()]) type MockGet func(innerClient client.Client, ctx context.Context, key client.ObjectKey, obj runtime.Object) (MockHandled, error) type MockList func(innerClient client.Client, ctx context.Context, opts *client.ListOptions, list runtime.Object) (MockHandled, error) type MockCreate func(innerClient client.Client, ctx context.Context, obj runtime.Object) (MockHandled, error) type MockDelete func(innerClient client.Client, ctx context.Context, obj runtime.Object) (MockHandled, error) type MockUpdate func(innerClient client.Client, ctx context.Context, obj runtime.Object) (MockHandled, error) var _ client.Client = (*MockClient)(nil) // mockClient is a client.Client that allows mock responses to be returned, instead of calling the // inner client.Client. type MockClient struct { innerClient client.Client mocks Mocks } // The mocks to run on each function type. Each function will run through the mocks in its list // until one responds with 'Handled'. If there is more than one mock in the list, then the one that // responds 'Handled' will be removed and not run on subsequent calls to the function. If no mocks // respond 'Handled', then the real underlying client is called. type Mocks struct { MockGets []MockGet MockLists []MockList MockCreates []MockCreate MockDeletes []MockDelete MockUpdates []MockUpdate } func NewMockClient(innerClient client.Client, mocks Mocks) *MockClient { return &MockClient{ innerClient: innerClient, mocks: mocks, } } func (m *MockClient) stopMocking() { m.mocks = Mocks{} } // All of the functions are handled almost identically: // 1. Run through the mocks in order: // a. If the mock handled the request, then: // i. If there is at least one other mock in the list, remove this mock. // ii. Return the response from the mock. // 2. No mock handled the request, so call the inner client. func (m *MockClient) Get(ctx context.Context, key client.ObjectKey, obj runtime.Object) error { for i, mockGet := range m.mocks.MockGets { handled, err := mockGet(m.innerClient, ctx, key, obj) if handled == Handled { if len(m.mocks.MockGets) > 1 { m.mocks.MockGets = append(m.mocks.MockGets[:i], m.mocks.MockGets[i+1:]...) } return err } } return m.innerClient.Get(ctx, key, obj) } func (m *MockClient) List(ctx context.Context, opts *client.ListOptions, list runtime.Object) error { for i, mockList := range m.mocks.MockLists { handled, err := mockList(m.innerClient, ctx, opts, list) if handled == Handled { if len(m.mocks.MockLists) > 1 { m.mocks.MockLists = append(m.mocks.MockLists[:i], m.mocks.MockLists[i+1:]...) } return err } } return m.innerClient.List(ctx, opts, list) } func (m *MockClient) Create(ctx context.Context, obj runtime.Object) error { for i, mockCreate := range m.mocks.MockCreates { handled, err := mockCreate(m.innerClient, ctx, obj) if handled == Handled { if len(m.mocks.MockCreates) > 1 { m.mocks.MockCreates = append(m.mocks.MockCreates[:i], m.mocks.MockCreates[i+1:]...) } return err } } return m.innerClient.Create(ctx, obj) } func (m *MockClient) Delete(ctx context.Context, obj runtime.Object, opts ...client.DeleteOptionFunc) error { for i, mockDelete := range m.mocks.MockDeletes { handled, err := mockDelete(m.innerClient, ctx, obj) if handled == Handled { if len(m.mocks.MockDeletes) > 1 { m.mocks.MockDeletes = append(m.mocks.MockDeletes[:i], m.mocks.MockDeletes[i+1:]...) } return err } } return m.innerClient.Delete(ctx, obj, opts...) } func (m *MockClient) Update(ctx context.Context, obj runtime.Object) error { for i, mockUpdate := range m.mocks.MockUpdates { handled, err := mockUpdate(m.innerClient, ctx, obj) if handled == Handled { if len(m.mocks.MockUpdates) > 1 { m.mocks.MockUpdates = append(m.mocks.MockUpdates[:i], m.mocks.MockUpdates[i+1:]...) } return err } } return m.innerClient.Update(ctx, obj) } func (m *MockClient) Status() client.StatusWriter { return m.innerClient.Status() } ================================================ FILE: rocketmq-knative/source/pkg/controller/testing/table.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package testing import ( "context" "fmt" "strings" "testing" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" "github.com/knative/eventing-contrib/pkg/controller/sdk" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/client-go/dynamic" dynamicfake "k8s.io/client-go/dynamic/fake" "k8s.io/client-go/kubernetes/scheme" "k8s.io/client-go/tools/cache" "knative.dev/pkg/apis" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/client/fake" "sigs.k8s.io/controller-runtime/pkg/reconcile" ) // TestCase holds a single row of our table test. type TestCase struct { // Name is a descriptive name for this test suitable as a first argument to t.Run() Name string // InitialState is the list of objects that already exists when reconciliation // starts. InitialState []runtime.Object Reconciles runtime.Object // ReconcileKey is the key of the object to reconcile in namespace/name form. ReconcileKey string // WantErr is true when we expect the Reconcile function to return an error. WantErr bool // WantErrMsg contains the pattern to match the returned error message. // Implies WantErr = true. WantErrMsg string // WantResult is the reconcile result we expect to be returned from the // Reconcile function. WantResult reconcile.Result // WantResultObject is the reconcile result we expect to be returned from the // Reconcile function. WantResultObject runtime.Object // WantPresent holds the non-exclusive set of objects we expect to exist // after reconciliation completes. WantPresent []runtime.Object // WantAbsent holds the list of objects expected to not exist // after reconciliation completes. WantAbsent []runtime.Object // Mocks that tamper with the client's responses. Mocks Mocks // Scheme for the dynamic client Scheme *runtime.Scheme // Fake dynamic objects Objects []runtime.Object // OtherTestData is arbitrary data needed for the test. It is not used directly by the table // testing framework. Instead it is used in the test method. E.g. setting up the responses for a // fake GCP PubSub client can go in here, as no other field makes sense for it. OtherTestData map[string]interface{} // IgnoreTimes causes comparisons to ignore fields of type apis.VolatileTime. IgnoreTimes bool } // Runner returns a testing func that can be passed to t.Run. func (tc *TestCase) Runner(t *testing.T, r sdk.KnativeReconciler, c *MockClient) func(t *testing.T) { return func(t *testing.T) { result, recErr := tc.Reconcile(c, r) if err := tc.VerifyErr(recErr); err != nil { t.Error(err) } // Push back the reconciled changes into the client. if result != nil { c.Update(context.TODO(), result) } // Verifying should be done against the innerClient, never against mocks. c.stopMocking() if err := tc.VerifyWantPresent(c); err != nil { t.Error(err) } if err := tc.VerifyWantAbsent(c); err != nil { t.Error(err) } } } // GetDynamicClient returns the mockDynamicClient to use for this test case. func (tc *TestCase) GetDynamicClient() dynamic.Interface { if tc.Scheme == nil { return dynamicfake.NewSimpleDynamicClient(runtime.NewScheme(), tc.Objects...) } return dynamicfake.NewSimpleDynamicClient(tc.Scheme, tc.Objects...) } // GetClient returns the mockClient to use for this test case. func (tc *TestCase) GetClient() *MockClient { innerClient := fake.NewFakeClient(tc.InitialState...) return NewMockClient(innerClient, tc.Mocks) } // Reconcile calls the given reconciler's Reconcile() function with the test // case's reconcile request. func (tc *TestCase) Reconcile(c client.Client, r sdk.KnativeReconciler) (runtime.Object, error) { if tc.ReconcileKey == "" { return nil, fmt.Errorf("test did not set ReconcileKey") } ns, n, err := cache.SplitMetaNamespaceKey(tc.ReconcileKey) if err != nil { return nil, err } obj := tc.Reconciles.DeepCopyObject() err = c.Get(context.TODO(), client.ObjectKey{Namespace: ns, Name: n}, obj) if err != nil { // Not found is not an error. return nil, nil } return obj, r.Reconcile(context.TODO(), obj) } // VerifyErr verifies that the given error returned from Reconcile is the error // expected by the test case. func (tc *TestCase) VerifyErr(err error) error { // A non-empty WantErrMsg implies that an error is wanted. wantErr := tc.WantErr || tc.WantErrMsg != "" if wantErr && err == nil { return fmt.Errorf("want error, got nil") } if !wantErr && err != nil { return fmt.Errorf("want no error, got %v", err) } if err != nil { if diff := cmp.Diff(tc.WantErrMsg, err.Error()); diff != "" { return fmt.Errorf("incorrect error (-want, +got): %v", diff) } } return nil } // VerifyResult verifies that the given result returned from Reconcile is the // result expected by the test case. func (tc *TestCase) VerifyResult(result reconcile.Result) error { if diff := cmp.Diff(tc.WantResult, result); diff != "" { return fmt.Errorf("unexpected reconcile Result (-want +got) %v", diff) } return nil } // VerifyResult verifies that the given result returned from Reconcile is the // result expected by the test case. func (tc *TestCase) VerifyResultSDK(result runtime.Object) error { if diff := cmp.Diff(tc.WantResultObject, result); diff != "" { return fmt.Errorf("unexpected reconcile Result Object (-want +got) %v", diff) } return nil } type stateErrors struct { errors []error } func (se stateErrors) Error() string { msgs := make([]string, 0) for _, err := range se.errors { msgs = append(msgs, err.Error()) } return strings.Join(msgs, "\n") } // VerifyWantPresent verifies that the client contains all the objects expected // to be present after reconciliation. func (tc *TestCase) VerifyWantPresent(c client.Client) error { var errs stateErrors for _, wp := range tc.WantPresent { o, err := scheme.Scheme.New(wp.GetObjectKind().GroupVersionKind()) if err != nil { errs.errors = append(errs.errors, fmt.Errorf("error creating a copy of %T: %v", wp, err)) } acc, err := meta.Accessor(wp) if err != nil { errs.errors = append(errs.errors, fmt.Errorf("error getting accessor for %#v %v", wp, err)) } err = c.Get(context.TODO(), client.ObjectKey{Namespace: acc.GetNamespace(), Name: acc.GetName()}, o) if err != nil { if apierrors.IsNotFound(err) { errs.errors = append(errs.errors, fmt.Errorf("want present %T %s/%s, got absent", wp, acc.GetNamespace(), acc.GetName())) } else { errs.errors = append(errs.errors, fmt.Errorf("error getting %T %s/%s: %v", wp, acc.GetNamespace(), acc.GetName(), err)) } } diffOpts := cmp.Options{ // Ignore TypeMeta, since the objects created by the controller won't have // it cmpopts.IgnoreTypes(metav1.TypeMeta{}), } if tc.IgnoreTimes { // Ignore VolatileTime fields, since they rarely compare correctly. diffOpts = append(diffOpts, cmpopts.IgnoreTypes(apis.VolatileTime{})) } if diff := cmp.Diff(wp, o, diffOpts...); diff != "" { errs.errors = append(errs.errors, fmt.Errorf("Unexpected present %T %s/%s (-want +got):\n%v", wp, acc.GetNamespace(), acc.GetName(), diff)) } } if len(errs.errors) > 0 { return errs } return nil } // VerifyWantAbsent verifies that the client does not contain any of the objects // expected to be absent after reconciliation. func (tc *TestCase) VerifyWantAbsent(c client.Client) error { var errs stateErrors for _, wa := range tc.WantAbsent { acc, err := meta.Accessor(wa) if err != nil { errs.errors = append(errs.errors, fmt.Errorf("error getting accessor for %#v %v", wa, err)) } err = c.Get(context.TODO(), client.ObjectKey{Namespace: acc.GetNamespace(), Name: acc.GetName()}, wa) if err == nil { errs.errors = append(errs.errors, fmt.Errorf("want absent, got present %T %s/%s", wa, acc.GetNamespace(), acc.GetName())) } if !apierrors.IsNotFound(err) { errs.errors = append(errs.errors, fmt.Errorf("error getting %T %s/%s: %v", wa, acc.GetNamespace(), acc.GetName(), err)) } } if len(errs.errors) > 0 { return errs } return nil } ================================================ FILE: rocketmq-knative/source/pkg/kncloudevents/good_client.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package kncloudevents import ( cloudevents "github.com/cloudevents/sdk-go" "github.com/cloudevents/sdk-go/pkg/cloudevents/transport/http" ) func NewDefaultClient(target ...string) (cloudevents.Client, error) { tOpts := []http.Option{cloudevents.WithBinaryEncoding()} if len(target) > 0 && target[0] != "" { tOpts = append(tOpts, cloudevents.WithTarget(target[0])) } // Make an http transport for the CloudEvents client. t, err := cloudevents.NewHTTPTransport(tOpts...) if err != nil { return nil, err } // Use the transport to make a new CloudEvents client. c, err := cloudevents.NewClient(t, cloudevents.WithUUIDs(), cloudevents.WithTimeNow(), ) if err != nil { return nil, err } return c, nil } ================================================ FILE: rocketmq-knative/source/pkg/reconciler/creds.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package rocketmq import ( "context" "encoding/json" "fmt" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis/sources/v1alpha1" "go.uber.org/zap" v1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" "knative.dev/pkg/logging" "sigs.k8s.io/controller-runtime/pkg/client" ) func GetCredentials(ctx context.Context, client client.Client, src *v1alpha1.RocketMQSource) (*v1alpha1.Credentials, error) { if src.Spec.AccessToken.SecretKeyRef == nil { return nil, fmt.Errorf("nil secretKeyRef") } return GetCredentialsByName(ctx, client, src.Namespace, src.Spec.AccessToken.SecretKeyRef.Name, src.Spec.AccessToken.SecretKeyRef.Key) } func GetCredentialsByName(ctx context.Context, client client.Client, namespace, name, key string) (*v1alpha1.Credentials, error) { secret := &v1.Secret{} err := client.Get(ctx, types.NamespacedName{Namespace: namespace, Name: name}, secret) if err != nil { logging.FromContext(ctx).Error("Unable to read the secretRef", zap.Any("secret", name)) return nil, err } bytes, present := secret.Data[key] if !present { logging.FromContext(ctx).Error("Secret did not contain the key", zap.String("key", key)) return nil, fmt.Errorf("secretRef did not contain the key '%s'", key) } credentials := &v1alpha1.Credentials{} if err := json.Unmarshal(bytes, credentials); err != nil { logging.FromContext(ctx).Error("Unable to create the RocketMQ credential", zap.Error(err)) return nil, err } return credentials, nil } ================================================ FILE: rocketmq-knative/source/pkg/reconciler/eventtype/eventtype.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package eventtype import ( "context" "fmt" "k8s.io/apimachinery/pkg/api/equality" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/reconciler/eventtype/resources" eventingv1alpha1 "github.com/knative/eventing/pkg/apis/eventing/v1alpha1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/runtime" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" ) // Reconciler is a helper struct that can be used by any source in order to reconcile its EventTypes. type Reconciler struct { Client client.Client Scheme *runtime.Scheme } // ReconcilerArgs are the arguments needed to reconcile EventTypes. type ReconcilerArgs struct { Specs []eventingv1alpha1.EventTypeSpec Namespace string Labels map[string]string Kind string } // Reconcile reconciles the EventTypes taken from 'args', and sets 'owner' as the controller. func (r *Reconciler) Reconcile(ctx context.Context, owner metav1.Object, args *ReconcilerArgs) error { current, err := r.getEventTypes(ctx, args.Namespace, args.Labels, owner) if err != nil { return err } expected, err := r.makeEventTypes(args, owner) if err != nil { return err } toCreate, toDelete := r.computeDiff(current, expected) for _, eventType := range toDelete { err = r.Client.Delete(ctx, &eventType) if err != nil { return err } } for _, eventType := range toCreate { err = r.Client.Create(ctx, &eventType) if err != nil { return err } } return nil } // getEventTypes returns the EventTypes controlled by 'owner'. func (r *Reconciler) getEventTypes(ctx context.Context, namespace string, lbs map[string]string, owner metav1.Object) ([]eventingv1alpha1.EventType, error) { eventTypes := make([]eventingv1alpha1.EventType, 0) opts := &client.ListOptions{ Namespace: namespace, LabelSelector: labels.SelectorFromSet(lbs), } el := &eventingv1alpha1.EventTypeList{} if err := r.Client.List(ctx, opts, el); err != nil { return nil, err } for _, e := range el.Items { if metav1.IsControlledBy(&e, owner) { eventTypes = append(eventTypes, e) } } return eventTypes, nil } // makeEventTypes creates the in-memory representation of the EventTypes. func (r *Reconciler) makeEventTypes(args *ReconcilerArgs, owner metav1.Object) ([]eventingv1alpha1.EventType, error) { eventTypes := make([]eventingv1alpha1.EventType, 0) // Only create EventTypes for Broker sinks. // We add this check here in case the Source was changed from a Broker to non-Broker sink. // If so, we need to delete the existing EventTypes, thus we return empty expected. if args.Kind != "Broker" { return eventTypes, nil } for _, spec := range args.Specs { eventType := resources.MakeEventType(spec, args.Namespace, args.Labels) // Setting the reference to delete the EventType upon uninstalling the source. if err := controllerutil.SetControllerReference(owner, &eventType, r.Scheme); err != nil { return nil, err } eventTypes = append(eventTypes, eventType) } return eventTypes, nil } // computeDiff computes the EventTypes that need to be created and/or deleted based on the difference between // 'expected' and 'current'. It does so using all the EventType.Spec fields but Description as "primary key" of the EventTypes. func (r *Reconciler) computeDiff(current []eventingv1alpha1.EventType, expected []eventingv1alpha1.EventType) ([]eventingv1alpha1.EventType, []eventingv1alpha1.EventType) { toCreate := make([]eventingv1alpha1.EventType, 0) toDelete := make([]eventingv1alpha1.EventType, 0) currentMap := asMap(current, keyFromEventType) expectedMap := asMap(expected, keyFromEventType) // Iterate over the slices instead of the maps for predictable UT expectations. for _, e := range expected { // If it's not in the currentMap, we need to create it. if c, ok := currentMap[keyFromEventType(&e)]; !ok { toCreate = append(toCreate, e) } else { // If it is but the spec differs, then we need to delete it and create it again. if !equality.Semantic.DeepEqual(e.Spec, c.Spec) { toDelete = append(toDelete, c) toCreate = append(toCreate, e) } } } // Need to check whether the current EventTypes are not in the expected map. If so, we have to delete them. // This could happen when sources COs are edited, e.g., changing the topics in a Kafka CO. for _, c := range current { if _, ok := expectedMap[keyFromEventType(&c)]; !ok { toDelete = append(toDelete, c) } } return toCreate, toDelete } // asMap returns a map representation of 'eventTypes' list, by using the key given by 'keyFunc'. func asMap(eventTypes []eventingv1alpha1.EventType, keyFunc func(*eventingv1alpha1.EventType) string) map[string]eventingv1alpha1.EventType { eventTypesAsMap := make(map[string]eventingv1alpha1.EventType, 0) for _, eventType := range eventTypes { key := keyFunc(&eventType) eventTypesAsMap[key] = eventType } return eventTypesAsMap } func keyFromEventType(eventType *eventingv1alpha1.EventType) string { return fmt.Sprintf("%s_%s_%s_%s", eventType.Spec.Type, eventType.Spec.Source, eventType.Spec.Schema, eventType.Spec.Broker) } ================================================ FILE: rocketmq-knative/source/pkg/reconciler/eventtype/resources/eventtype.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package resources import ( "fmt" "regexp" "strings" eventingv1alpha1 "github.com/knative/eventing/pkg/apis/eventing/v1alpha1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/validation" ) const ( // Number of characters to keep available just in case the prefix used in generateName // exceeds the maximum allowed for k8s names. generateNameSafety = 10 ) // Only allow alphanumeric, '-' or '.'. var validChars = regexp.MustCompile(`[^-\.a-z0-9]+`) // MakeEventType creates the in-memory representation of the EventType in the specified namespace, with the given spec, // and label. func MakeEventType(spec eventingv1alpha1.EventTypeSpec, namespace string, lbl map[string]string) eventingv1alpha1.EventType { return eventingv1alpha1.EventType{ ObjectMeta: metav1.ObjectMeta{ GenerateName: fmt.Sprintf("%s-", toDNS1123Subdomain(spec.Type)), Labels: lbl, Namespace: namespace, }, Spec: spec, } } // Converts 'name' to a valid DNS1123 subdomain, required for object names in K8s. func toDNS1123Subdomain(name string) string { // If it is not a valid DNS1123 subdomain, make it a valid one. if msgs := validation.IsDNS1123Subdomain(name); len(msgs) != 0 { // If the length exceeds the max, cut it and leave some room for a potential generated UUID. if len(name) > validation.DNS1123SubdomainMaxLength { name = name[:validation.DNS1123SubdomainMaxLength-generateNameSafety] } name = strings.ToLower(name) name = validChars.ReplaceAllString(name, "") // Only start/end with alphanumeric. name = strings.Trim(name, "-.") } return name } ================================================ FILE: rocketmq-knative/source/pkg/reconciler/resources/receive_adapter.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package resources import ( "fmt" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis/sources/v1alpha1" v1 "k8s.io/api/apps/v1" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) // ReceiveAdapterArgs are the arguments needed to create a RocketMQ Source Receive Adapter. Every // field is required. type ReceiveAdapterArgs struct { Image string Source *v1alpha1.RocketMQSource Labels map[string]string SubscriptionID string SinkURI string // TransformerURI string } // MakeReceiveAdapter generates (but does not insert into K8s) the Receive Adapter Deployment for func MakeReceiveAdapter(args *ReceiveAdapterArgs) *v1.Deployment { replicas := int32(1) secretName := "" seretKey := "" if(args.Source.Spec.AccessToken.SecretKeyRef != nil){ secretName = args.Source.Spec.AccessToken.SecretKeyRef.Name seretKey = args.Source.Spec.AccessToken.SecretKeyRef.Key } return &v1.Deployment{ ObjectMeta: metav1.ObjectMeta{ Namespace: args.Source.Namespace, GenerateName: fmt.Sprintf("rocketmq-%s-", args.Source.Name), Labels: args.Labels, }, Spec: v1.DeploymentSpec{ Selector: &metav1.LabelSelector{ MatchLabels: args.Labels, }, Replicas: &replicas, Template: corev1.PodTemplateSpec{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ "sidecar.istio.io/inject": "true", }, Labels: args.Labels, }, Spec: corev1.PodSpec{ ServiceAccountName: args.Source.Spec.ServiceAccountName, Containers: []corev1.Container{ { Name: "receive-adapter", Image: args.Image, Env: []corev1.EnvVar{ { Name: "SECRET_NAME", Value:secretName, }, { Name: "SECRET_KEY", Value:seretKey, }, { Name: "NAMESPACE", ValueFrom: &corev1.EnvVarSource{ FieldRef: &corev1.ObjectFieldSelector{ FieldPath: "metadata.namespace", }, }, }, { Name: "TOPIC", Value: args.Source.Spec.Topic, }, { Name: "SUBSCRIPTION_ID", Value: args.SubscriptionID, }, { Name: "SINK_URI", Value: args.SinkURI, }, { Name: "NAMESRVADDR", Value: args.Source.Spec.NamesrvAddr, }, { Name: "RNAMESPACE", Value: args.Source.Spec.Namespace, }, { Name: "GROUPNAME", Value: args.Source.Spec.GroupName, }, }, }, }, }, }, }, } } ================================================ FILE: rocketmq-knative/source/pkg/reconciler/rocketmqsource.go ================================================ /* Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You 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. */ package rocketmq import ( "context" "fmt" "log" "os" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/apis/sources/v1alpha1" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/reconciler/resources" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/controller/sdk" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/controller/sinks" "github.com/apache/rocketmq-externals/rocketmq-knative/source/pkg/reconciler/eventtype" eventingv1alpha1 "github.com/knative/eventing/pkg/apis/eventing/v1alpha1" "go.uber.org/zap" appsv1 "k8s.io/api/apps/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/labels" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/util/sets" "knative.dev/pkg/logging" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" "sigs.k8s.io/controller-runtime/pkg/manager" ) const ( // controllerAgentName is the string used by this controller to identify // itself when creating events. controllerAgentName = "source-controller" // raImageEnvVar is the name of the environment variable that contains the receive adapter's // image. It must be defined. raImageEnvVar = "RocketMQ_RA_IMAGE" finalizerName = controllerAgentName ) /** * USER ACTION REQUIRED: This is a scaffold file intended for the user to modify with their own Controller * business logic. Delete these comments after modifying this file.* */ // Add creates a new RocketMQSource Controller and adds it to the Manager with default RBAC. The Manager will set fields on the Controller // and Start it when the Manager is Started. func Add(mgr manager.Manager, logger *zap.SugaredLogger) error { raImage, defined := os.LookupEnv(raImageEnvVar) if !defined { return fmt.Errorf("required environment variable '%s' not defined", raImageEnvVar) } log.Println("Adding the RocketMQ Source controller.") p := &sdk.Provider{ AgentName: controllerAgentName, Parent: &v1alpha1.RocketMQSource{}, Owns: []runtime.Object{&appsv1.Deployment{}, &eventingv1alpha1.EventType{}}, Reconciler: &reconciler{ scheme: mgr.GetScheme(), receiveAdapterImage: raImage, eventTypeReconciler: eventtype.Reconciler{ Scheme: mgr.GetScheme(), }, }, } return p.Add(mgr, logger) } type reconciler struct { client client.Client scheme *runtime.Scheme receiveAdapterImage string eventTypeReconciler eventtype.Reconciler } func (r *reconciler) InjectClient(c client.Client) error { r.client = c r.eventTypeReconciler.Client = c return nil } func (r *reconciler) Reconcile(ctx context.Context, object runtime.Object) error { logger := logging.FromContext(ctx).Desugar() src, ok := object.(*v1alpha1.RocketMQSource) if !ok { logger.Error("could not find RocketMQ source", zap.Any("object", object)) return nil } deletionTimestamp := src.DeletionTimestamp if deletionTimestamp != nil { r.removeFinalizer(src) return nil } r.addFinalizer(src) src.Status.InitializeConditions() sinkURI, err := sinks.GetSinkURI(ctx, r.client, src.Spec.Sink, src.Namespace) if err != nil { src.Status.MarkNoSink("NotFound", "") return err } src.Status.MarkSink(sinkURI) _, err = r.createReceiveAdapter(ctx, src, "knative-eventing-default", sinkURI) if err != nil { logger.Error("Unable to create the receive adapter", zap.Error(err)) return err } src.Status.MarkDeployed() err = r.reconcileEventTypes(ctx, src) if err != nil { logger.Error("Unable to reconcile the event types", zap.Error(err)) return err } src.Status.MarkEventTypes() return nil } func (r *reconciler) addFinalizer(s *v1alpha1.RocketMQSource) { finalizers := sets.NewString(s.Finalizers...) finalizers.Insert(finalizerName) s.Finalizers = finalizers.List() } func (r *reconciler) removeFinalizer(s *v1alpha1.RocketMQSource) { finalizers := sets.NewString(s.Finalizers...) finalizers.Delete(finalizerName) s.Finalizers = finalizers.List() } func (r *reconciler) createReceiveAdapter(ctx context.Context, src *v1alpha1.RocketMQSource, subscriptionID, sinkURI string ) (*appsv1.Deployment, error) { ra, err := r.getReceiveAdapter(ctx, src) if err != nil && !apierrors.IsNotFound(err) { logging.FromContext(ctx).Error("Unable to get an existing receive adapter", zap.Error(err)) return nil, err } if ra != nil { logging.FromContext(ctx).Desugar().Info("Reusing existing receive adapter", zap.Any("receiveAdapter", ra)) return ra, nil } svc := resources.MakeReceiveAdapter(&resources.ReceiveAdapterArgs{ Image: r.receiveAdapterImage, Source: src, Labels: getLabels(src), SubscriptionID: subscriptionID, SinkURI: sinkURI, }) if err := controllerutil.SetControllerReference(src, svc, r.scheme); err != nil { return nil, err } err = r.client.Create(ctx, svc) logging.FromContext(ctx).Desugar().Info("Receive Adapter created.", zap.Error(err), zap.Any("receiveAdapter", svc)) return svc, err } func (r *reconciler) getReceiveAdapter(ctx context.Context, src *v1alpha1.RocketMQSource) (*appsv1.Deployment, error) { dl := &appsv1.DeploymentList{} err := r.client.List(ctx, &client.ListOptions{ Namespace: src.Namespace, LabelSelector: r.getLabelSelector(src), // TODO this is only needed by the fake client. Real K8s does not need it. Remove it once // the fake is fixed. Raw: &metav1.ListOptions{ TypeMeta: metav1.TypeMeta{ APIVersion: appsv1.SchemeGroupVersion.String(), Kind: "Deployment", }, }, }, dl) if err != nil { logging.FromContext(ctx).Desugar().Error("Unable to list deployments: %v", zap.Error(err)) return nil, err } for _, dep := range dl.Items { if metav1.IsControlledBy(&dep, src) { return &dep, nil } } return nil, apierrors.NewNotFound(schema.GroupResource{}, "") } func (r *reconciler) getLabelSelector(src *v1alpha1.RocketMQSource) labels.Selector { return labels.SelectorFromSet(getLabels(src)) } func getLabels(src *v1alpha1.RocketMQSource) map[string]string { return map[string]string{ "knative-eventing-source": controllerAgentName, "knative-eventing-source-name": src.Name, } } func (r *reconciler) reconcileEventTypes(ctx context.Context, src *v1alpha1.RocketMQSource) error { args := r.newEventTypeReconcilerArgs(src) return r.eventTypeReconciler.Reconcile(ctx, src, args) } func (r *reconciler) newEventTypeReconcilerArgs(src *v1alpha1.RocketMQSource) *eventtype.ReconcilerArgs { specs := make([]eventingv1alpha1.EventTypeSpec, 0) spec := eventingv1alpha1.EventTypeSpec{ Type: v1alpha1.RocketMQSourceEventType, Source: v1alpha1.RocketMQEventSource(src.Spec.Topic), Broker: src.Spec.Sink.Name, } specs = append(specs, spec) return &eventtype.ReconcilerArgs{ Specs: specs, Namespace: src.Namespace, Labels: getLabels(src), Kind: src.Spec.Sink.Kind, } } func generateSubName(src *v1alpha1.RocketMQSource) string { return fmt.Sprintf("knative-eventing-%s-%s-%s", src.Namespace, src.Name, src.UID) } ================================================ FILE: rocketmq-knative/source/sample/apacherocketmqsource.yaml ================================================ apiVersion: sources.eventing.knative.dev/v1alpha1 kind: RocketMQSource metadata: labels: controller-tools.k8s.io: "1.0" name: apacherocketmqsource spec: topic: test namesrvAddr: xx.xx.xx.xx:9876 groupName: group1 sink: apiVersion: serving.knative.dev/v1 kind: Service name: event-display ================================================ FILE: rocketmq-knative/source/sample/event-display.yaml ================================================ apiVersion: serving.knative.dev/v1 kind: Service metadata: name: event-display namespace: default spec: template: spec: containers: - image: docker.io/apacherocketmq/event-display:1.0.0 ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/AUTHORS ================================================ # This is the official list of cloud authors for copyright purposes. # This file is distinct from the CONTRIBUTORS files. # See the latter for an explanation. # Names should be added to this file as: # Name or Organization # The email address is not required for organizations. Filippo Valsorda Google Inc. Ingo Oeser Palm Stone Games, Inc. Paweł Knap Péter Szilágyi Tyler Treat ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/CONTRIBUTORS ================================================ # People who have agreed to one of the CLAs and can contribute patches. # The AUTHORS file lists the copyright holders; this file # lists people. For example, Google employees are listed here # but not in AUTHORS, because Google holds the copyright. # # https://developers.google.com/open-source/cla/individual # https://developers.google.com/open-source/cla/corporate # # Names should be added to this file as: # Name # Keep the list alphabetically sorted. Alexis Hunt Andreas Litt Andrew Gerrand Brad Fitzpatrick Burcu Dogan Dave Day David Sansome David Symonds Filippo Valsorda Glenn Lewis Ingo Oeser James Hall Johan Euphrosine Jonathan Amsterdam Kunpei Sakai Luna Duclos Magnus Hiie Mario Castro Michael McGreevy Omar Jarjur Paweł Knap Péter Szilágyi Sarah Adams Thanatat Tamtan Toby Burress Tuo Shan Tyler Treat ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/LICENSE ================================================ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] 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. ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/compute/metadata/metadata.go ================================================ // Copyright 2014 Google Inc. 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. // Package metadata provides access to Google Compute Engine (GCE) // metadata and API service accounts. // // This package is a wrapper around the GCE metadata service, // as documented at https://developers.google.com/compute/docs/metadata. package metadata // import "cloud.google.com/go/compute/metadata" import ( "encoding/json" "fmt" "io/ioutil" "net" "net/http" "net/url" "os" "runtime" "strings" "sync" "time" "golang.org/x/net/context" "golang.org/x/net/context/ctxhttp" ) const ( // metadataIP is the documented metadata server IP address. metadataIP = "169.254.169.254" // metadataHostEnv is the environment variable specifying the // GCE metadata hostname. If empty, the default value of // metadataIP ("169.254.169.254") is used instead. // This is variable name is not defined by any spec, as far as // I know; it was made up for the Go package. metadataHostEnv = "GCE_METADATA_HOST" userAgent = "gcloud-golang/0.1" ) type cachedValue struct { k string trim bool mu sync.Mutex v string } var ( projID = &cachedValue{k: "project/project-id", trim: true} projNum = &cachedValue{k: "project/numeric-project-id", trim: true} instID = &cachedValue{k: "instance/id", trim: true} ) var ( metaClient = &http.Client{ Transport: &http.Transport{ Dial: (&net.Dialer{ Timeout: 2 * time.Second, KeepAlive: 30 * time.Second, }).Dial, ResponseHeaderTimeout: 2 * time.Second, }, } subscribeClient = &http.Client{ Transport: &http.Transport{ Dial: (&net.Dialer{ Timeout: 2 * time.Second, KeepAlive: 30 * time.Second, }).Dial, }, } ) // NotDefinedError is returned when requested metadata is not defined. // // The underlying string is the suffix after "/computeMetadata/v1/". // // This error is not returned if the value is defined to be the empty // string. type NotDefinedError string func (suffix NotDefinedError) Error() string { return fmt.Sprintf("metadata: GCE metadata %q not defined", string(suffix)) } // Get returns a value from the metadata service. // The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/". // // If the GCE_METADATA_HOST environment variable is not defined, a default of // 169.254.169.254 will be used instead. // // If the requested metadata is not defined, the returned error will // be of type NotDefinedError. func Get(suffix string) (string, error) { val, _, err := getETag(metaClient, suffix) return val, err } // getETag returns a value from the metadata service as well as the associated // ETag using the provided client. This func is otherwise equivalent to Get. func getETag(client *http.Client, suffix string) (value, etag string, err error) { // Using a fixed IP makes it very difficult to spoof the metadata service in // a container, which is an important use-case for local testing of cloud // deployments. To enable spoofing of the metadata service, the environment // variable GCE_METADATA_HOST is first inspected to decide where metadata // requests shall go. host := os.Getenv(metadataHostEnv) if host == "" { // Using 169.254.169.254 instead of "metadata" here because Go // binaries built with the "netgo" tag and without cgo won't // know the search suffix for "metadata" is // ".google.internal", and this IP address is documented as // being stable anyway. host = metadataIP } url := "http://" + host + "/computeMetadata/v1/" + suffix req, _ := http.NewRequest("GET", url, nil) req.Header.Set("Metadata-Flavor", "Google") req.Header.Set("User-Agent", userAgent) res, err := client.Do(req) if err != nil { return "", "", err } defer res.Body.Close() if res.StatusCode == http.StatusNotFound { return "", "", NotDefinedError(suffix) } if res.StatusCode != 200 { return "", "", fmt.Errorf("status code %d trying to fetch %s", res.StatusCode, url) } all, err := ioutil.ReadAll(res.Body) if err != nil { return "", "", err } return string(all), res.Header.Get("Etag"), nil } func getTrimmed(suffix string) (s string, err error) { s, err = Get(suffix) s = strings.TrimSpace(s) return } func (c *cachedValue) get() (v string, err error) { defer c.mu.Unlock() c.mu.Lock() if c.v != "" { return c.v, nil } if c.trim { v, err = getTrimmed(c.k) } else { v, err = Get(c.k) } if err == nil { c.v = v } return } var ( onGCEOnce sync.Once onGCE bool ) // OnGCE reports whether this process is running on Google Compute Engine. func OnGCE() bool { onGCEOnce.Do(initOnGCE) return onGCE } func initOnGCE() { onGCE = testOnGCE() } func testOnGCE() bool { // The user explicitly said they're on GCE, so trust them. if os.Getenv(metadataHostEnv) != "" { return true } ctx, cancel := context.WithCancel(context.Background()) defer cancel() resc := make(chan bool, 2) // Try two strategies in parallel. // See https://github.com/GoogleCloudPlatform/google-cloud-go/issues/194 go func() { req, _ := http.NewRequest("GET", "http://"+metadataIP, nil) req.Header.Set("User-Agent", userAgent) res, err := ctxhttp.Do(ctx, metaClient, req) if err != nil { resc <- false return } defer res.Body.Close() resc <- res.Header.Get("Metadata-Flavor") == "Google" }() go func() { addrs, err := net.LookupHost("metadata.google.internal") if err != nil || len(addrs) == 0 { resc <- false return } resc <- strsContains(addrs, metadataIP) }() tryHarder := systemInfoSuggestsGCE() if tryHarder { res := <-resc if res { // The first strategy succeeded, so let's use it. return true } // Wait for either the DNS or metadata server probe to // contradict the other one and say we are running on // GCE. Give it a lot of time to do so, since the system // info already suggests we're running on a GCE BIOS. timer := time.NewTimer(5 * time.Second) defer timer.Stop() select { case res = <-resc: return res case <-timer.C: // Too slow. Who knows what this system is. return false } } // There's no hint from the system info that we're running on // GCE, so use the first probe's result as truth, whether it's // true or false. The goal here is to optimize for speed for // users who are NOT running on GCE. We can't assume that // either a DNS lookup or an HTTP request to a blackholed IP // address is fast. Worst case this should return when the // metaClient's Transport.ResponseHeaderTimeout or // Transport.Dial.Timeout fires (in two seconds). return <-resc } // systemInfoSuggestsGCE reports whether the local system (without // doing network requests) suggests that we're running on GCE. If this // returns true, testOnGCE tries a bit harder to reach its metadata // server. func systemInfoSuggestsGCE() bool { if runtime.GOOS != "linux" { // We don't have any non-Linux clues available, at least yet. return false } slurp, _ := ioutil.ReadFile("/sys/class/dmi/id/product_name") name := strings.TrimSpace(string(slurp)) return name == "Google" || name == "Google Compute Engine" } // Subscribe subscribes to a value from the metadata service. // The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/". // The suffix may contain query parameters. // // Subscribe calls fn with the latest metadata value indicated by the provided // suffix. If the metadata value is deleted, fn is called with the empty string // and ok false. Subscribe blocks until fn returns a non-nil error or the value // is deleted. Subscribe returns the error value returned from the last call to // fn, which may be nil when ok == false. func Subscribe(suffix string, fn func(v string, ok bool) error) error { const failedSubscribeSleep = time.Second * 5 // First check to see if the metadata value exists at all. val, lastETag, err := getETag(subscribeClient, suffix) if err != nil { return err } if err := fn(val, true); err != nil { return err } ok := true if strings.ContainsRune(suffix, '?') { suffix += "&wait_for_change=true&last_etag=" } else { suffix += "?wait_for_change=true&last_etag=" } for { val, etag, err := getETag(subscribeClient, suffix+url.QueryEscape(lastETag)) if err != nil { if _, deleted := err.(NotDefinedError); !deleted { time.Sleep(failedSubscribeSleep) continue // Retry on other errors. } ok = false } lastETag = etag if err := fn(val, ok); err != nil || !ok { return err } } } // ProjectID returns the current instance's project ID string. func ProjectID() (string, error) { return projID.get() } // NumericProjectID returns the current instance's numeric project ID. func NumericProjectID() (string, error) { return projNum.get() } // InternalIP returns the instance's primary internal IP address. func InternalIP() (string, error) { return getTrimmed("instance/network-interfaces/0/ip") } // ExternalIP returns the instance's primary external (public) IP address. func ExternalIP() (string, error) { return getTrimmed("instance/network-interfaces/0/access-configs/0/external-ip") } // Hostname returns the instance's hostname. This will be of the form // ".c..internal". func Hostname() (string, error) { return getTrimmed("instance/hostname") } // InstanceTags returns the list of user-defined instance tags, // assigned when initially creating a GCE instance. func InstanceTags() ([]string, error) { var s []string j, err := Get("instance/tags") if err != nil { return nil, err } if err := json.NewDecoder(strings.NewReader(j)).Decode(&s); err != nil { return nil, err } return s, nil } // InstanceID returns the current VM's numeric instance ID. func InstanceID() (string, error) { return instID.get() } // InstanceName returns the current VM's instance ID string. func InstanceName() (string, error) { host, err := Hostname() if err != nil { return "", err } return strings.Split(host, ".")[0], nil } // Zone returns the current VM's zone, such as "us-central1-b". func Zone() (string, error) { zone, err := getTrimmed("instance/zone") // zone is of the form "projects//zones/". if err != nil { return "", err } return zone[strings.LastIndex(zone, "/")+1:], nil } // InstanceAttributes returns the list of user-defined attributes, // assigned when initially creating a GCE VM instance. The value of an // attribute can be obtained with InstanceAttributeValue. func InstanceAttributes() ([]string, error) { return lines("instance/attributes/") } // ProjectAttributes returns the list of user-defined attributes // applying to the project as a whole, not just this VM. The value of // an attribute can be obtained with ProjectAttributeValue. func ProjectAttributes() ([]string, error) { return lines("project/attributes/") } func lines(suffix string) ([]string, error) { j, err := Get(suffix) if err != nil { return nil, err } s := strings.Split(strings.TrimSpace(j), "\n") for i := range s { s[i] = strings.TrimSpace(s[i]) } return s, nil } // InstanceAttributeValue returns the value of the provided VM // instance attribute. // // If the requested attribute is not defined, the returned error will // be of type NotDefinedError. // // InstanceAttributeValue may return ("", nil) if the attribute was // defined to be the empty string. func InstanceAttributeValue(attr string) (string, error) { return Get("instance/attributes/" + attr) } // ProjectAttributeValue returns the value of the provided // project attribute. // // If the requested attribute is not defined, the returned error will // be of type NotDefinedError. // // ProjectAttributeValue may return ("", nil) if the attribute was // defined to be the empty string. func ProjectAttributeValue(attr string) (string, error) { return Get("project/attributes/" + attr) } // Scopes returns the service account scopes for the given account. // The account may be empty or the string "default" to use the instance's // main account. func Scopes(serviceAccount string) ([]string, error) { if serviceAccount == "" { serviceAccount = "default" } return lines("instance/service-accounts/" + serviceAccount + "/scopes") } func strsContains(ss []string, s string) bool { for _, v := range ss { if v == s { return true } } return false } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/iam/iam.go ================================================ // Copyright 2016 Google Inc. 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. // Package iam supports the resource-specific operations of Google Cloud // IAM (Identity and Access Management) for the Google Cloud Libraries. // See https://cloud.google.com/iam for more about IAM. // // Users of the Google Cloud Libraries will typically not use this package // directly. Instead they will begin with some resource that supports IAM, like // a pubsub topic, and call its IAM method to get a Handle for that resource. package iam import ( "time" gax "github.com/googleapis/gax-go" "golang.org/x/net/context" pb "google.golang.org/genproto/googleapis/iam/v1" "google.golang.org/grpc" "google.golang.org/grpc/codes" ) // client abstracts the IAMPolicy API to allow multiple implementations. type client interface { Get(ctx context.Context, resource string) (*pb.Policy, error) Set(ctx context.Context, resource string, p *pb.Policy) error Test(ctx context.Context, resource string, perms []string) ([]string, error) } // grpcClient implements client for the standard gRPC-based IAMPolicy service. type grpcClient struct { c pb.IAMPolicyClient } var withRetry = gax.WithRetry(func() gax.Retryer { return gax.OnCodes([]codes.Code{ codes.DeadlineExceeded, codes.Unavailable, }, gax.Backoff{ Initial: 100 * time.Millisecond, Max: 60 * time.Second, Multiplier: 1.3, }) }) func (g *grpcClient) Get(ctx context.Context, resource string) (*pb.Policy, error) { var proto *pb.Policy err := gax.Invoke(ctx, func(ctx context.Context, _ gax.CallSettings) error { var err error proto, err = g.c.GetIamPolicy(ctx, &pb.GetIamPolicyRequest{Resource: resource}) return err }, withRetry) if err != nil { return nil, err } return proto, nil } func (g *grpcClient) Set(ctx context.Context, resource string, p *pb.Policy) error { return gax.Invoke(ctx, func(ctx context.Context, _ gax.CallSettings) error { _, err := g.c.SetIamPolicy(ctx, &pb.SetIamPolicyRequest{ Resource: resource, Policy: p, }) return err }, withRetry) } func (g *grpcClient) Test(ctx context.Context, resource string, perms []string) ([]string, error) { var res *pb.TestIamPermissionsResponse err := gax.Invoke(ctx, func(ctx context.Context, _ gax.CallSettings) error { var err error res, err = g.c.TestIamPermissions(ctx, &pb.TestIamPermissionsRequest{ Resource: resource, Permissions: perms, }) return err }, withRetry) if err != nil { return nil, err } return res.Permissions, nil } // A Handle provides IAM operations for a resource. type Handle struct { c client resource string } // InternalNewHandle is for use by the Google Cloud Libraries only. // // InternalNewHandle returns a Handle for resource. // The conn parameter refers to a server that must support the IAMPolicy service. func InternalNewHandle(conn *grpc.ClientConn, resource string) *Handle { return InternalNewHandleClient(&grpcClient{c: pb.NewIAMPolicyClient(conn)}, resource) } // InternalNewHandleClient is for use by the Google Cloud Libraries only. // // InternalNewHandleClient returns a Handle for resource using the given // client implementation. func InternalNewHandleClient(c client, resource string) *Handle { return &Handle{ c: c, resource: resource, } } // Policy retrieves the IAM policy for the resource. func (h *Handle) Policy(ctx context.Context) (*Policy, error) { proto, err := h.c.Get(ctx, h.resource) if err != nil { return nil, err } return &Policy{InternalProto: proto}, nil } // SetPolicy replaces the resource's current policy with the supplied Policy. // // If policy was created from a prior call to Get, then the modification will // only succeed if the policy has not changed since the Get. func (h *Handle) SetPolicy(ctx context.Context, policy *Policy) error { return h.c.Set(ctx, h.resource, policy.InternalProto) } // TestPermissions returns the subset of permissions that the caller has on the resource. func (h *Handle) TestPermissions(ctx context.Context, permissions []string) ([]string, error) { return h.c.Test(ctx, h.resource, permissions) } // A RoleName is a name representing a collection of permissions. type RoleName string // Common role names. const ( Owner RoleName = "roles/owner" Editor RoleName = "roles/editor" Viewer RoleName = "roles/viewer" ) const ( // AllUsers is a special member that denotes all users, even unauthenticated ones. AllUsers = "allUsers" // AllAuthenticatedUsers is a special member that denotes all authenticated users. AllAuthenticatedUsers = "allAuthenticatedUsers" ) // A Policy is a list of Bindings representing roles // granted to members. // // The zero Policy is a valid policy with no bindings. type Policy struct { // TODO(jba): when type aliases are available, put Policy into an internal package // and provide an exported alias here. // This field is exported for use by the Google Cloud Libraries only. // It may become unexported in a future release. InternalProto *pb.Policy } // Members returns the list of members with the supplied role. // The return value should not be modified. Use Add and Remove // to modify the members of a role. func (p *Policy) Members(r RoleName) []string { b := p.binding(r) if b == nil { return nil } return b.Members } // HasRole reports whether member has role r. func (p *Policy) HasRole(member string, r RoleName) bool { return memberIndex(member, p.binding(r)) >= 0 } // Add adds member member to role r if it is not already present. // A new binding is created if there is no binding for the role. func (p *Policy) Add(member string, r RoleName) { b := p.binding(r) if b == nil { if p.InternalProto == nil { p.InternalProto = &pb.Policy{} } p.InternalProto.Bindings = append(p.InternalProto.Bindings, &pb.Binding{ Role: string(r), Members: []string{member}, }) return } if memberIndex(member, b) < 0 { b.Members = append(b.Members, member) return } } // Remove removes member from role r if it is present. func (p *Policy) Remove(member string, r RoleName) { bi := p.bindingIndex(r) if bi < 0 { return } bindings := p.InternalProto.Bindings b := bindings[bi] mi := memberIndex(member, b) if mi < 0 { return } // Order doesn't matter for bindings or members, so to remove, move the last item // into the removed spot and shrink the slice. if len(b.Members) == 1 { // Remove binding. last := len(bindings) - 1 bindings[bi] = bindings[last] bindings[last] = nil p.InternalProto.Bindings = bindings[:last] return } // Remove member. // TODO(jba): worry about multiple copies of m? last := len(b.Members) - 1 b.Members[mi] = b.Members[last] b.Members[last] = "" b.Members = b.Members[:last] } // Roles returns the names of all the roles that appear in the Policy. func (p *Policy) Roles() []RoleName { if p.InternalProto == nil { return nil } var rns []RoleName for _, b := range p.InternalProto.Bindings { rns = append(rns, RoleName(b.Role)) } return rns } // binding returns the Binding for the suppied role, or nil if there isn't one. func (p *Policy) binding(r RoleName) *pb.Binding { i := p.bindingIndex(r) if i < 0 { return nil } return p.InternalProto.Bindings[i] } func (p *Policy) bindingIndex(r RoleName) int { if p.InternalProto == nil { return -1 } for i, b := range p.InternalProto.Bindings { if b.Role == string(r) { return i } } return -1 } // memberIndex returns the index of m in b's Members, or -1 if not found. func memberIndex(m string, b *pb.Binding) int { if b == nil { return -1 } for i, mm := range b.Members { if mm == m { return i } } return -1 } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/internal/optional/optional.go ================================================ // Copyright 2016 Google Inc. 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. // Package optional provides versions of primitive types that can // be nil. These are useful in methods that update some of an API object's // fields. package optional import ( "fmt" "strings" "time" ) type ( // Bool is either a bool or nil. Bool interface{} // String is either a string or nil. String interface{} // Int is either an int or nil. Int interface{} // Uint is either a uint or nil. Uint interface{} // Float64 is either a float64 or nil. Float64 interface{} // Duration is either a time.Duration or nil. Duration interface{} ) // ToBool returns its argument as a bool. // It panics if its argument is nil or not a bool. func ToBool(v Bool) bool { x, ok := v.(bool) if !ok { doPanic("Bool", v) } return x } // ToString returns its argument as a string. // It panics if its argument is nil or not a string. func ToString(v String) string { x, ok := v.(string) if !ok { doPanic("String", v) } return x } // ToInt returns its argument as an int. // It panics if its argument is nil or not an int. func ToInt(v Int) int { x, ok := v.(int) if !ok { doPanic("Int", v) } return x } // ToUint returns its argument as a uint. // It panics if its argument is nil or not a uint. func ToUint(v Uint) uint { x, ok := v.(uint) if !ok { doPanic("Uint", v) } return x } // ToFloat64 returns its argument as a float64. // It panics if its argument is nil or not a float64. func ToFloat64(v Float64) float64 { x, ok := v.(float64) if !ok { doPanic("Float64", v) } return x } // ToDuration returns its argument as a time.Duration. // It panics if its argument is nil or not a time.Duration. func ToDuration(v Duration) time.Duration { x, ok := v.(time.Duration) if !ok { doPanic("Duration", v) } return x } func doPanic(capType string, v interface{}) { panic(fmt.Sprintf("optional.%s value should be %s, got %T", capType, strings.ToLower(capType), v)) } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/internal/version/version.go ================================================ // Copyright 2016 Google Inc. 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. //go:generate ./update_version.sh // Package version contains version information for Google Cloud Client // Libraries for Go, as reported in request headers. package version import ( "runtime" "strings" "unicode" ) // Repo is the current version of the client libraries in this // repo. It should be a date in YYYYMMDD format. const Repo = "20180226" // Go returns the Go runtime version. The returned string // has no whitespace. func Go() string { return goVersion } var goVersion = goVer(runtime.Version()) const develPrefix = "devel +" func goVer(s string) string { if strings.HasPrefix(s, develPrefix) { s = s[len(develPrefix):] if p := strings.IndexFunc(s, unicode.IsSpace); p >= 0 { s = s[:p] } return s } if strings.HasPrefix(s, "go1") { s = s[2:] var prerelease string if p := strings.IndexFunc(s, notSemverRune); p >= 0 { s, prerelease = s[:p], s[p:] } if strings.HasSuffix(s, ".") { s += "0" } else if strings.Count(s, ".") < 2 { s += ".0" } if prerelease != "" { s += "-" + prerelease } return s } return "" } func notSemverRune(r rune) bool { return strings.IndexRune("0123456789.", r) < 0 } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/apiv1/doc.go ================================================ // Copyright 2018 Google LLC // // 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 // // https://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. // AUTO-GENERATED CODE. DO NOT EDIT. // Package pubsub is an auto-generated package for the // Google Cloud Pub/Sub API. // // NOTE: This package is in alpha. It is not stable, and is likely to change. // // Provides reliable, many-to-many, asynchronous messaging between // applications. // // Use the client at cloud.google.com/go/pubsub in preference to this. package pubsub // import "cloud.google.com/go/pubsub/apiv1" import ( "golang.org/x/net/context" "google.golang.org/grpc/metadata" ) func insertMetadata(ctx context.Context, mds ...metadata.MD) context.Context { out, _ := metadata.FromOutgoingContext(ctx) out = out.Copy() for _, md := range mds { for k, v := range md { out[k] = append(out[k], v...) } } return metadata.NewOutgoingContext(ctx, out) } // DefaultAuthScopes reports the default set of authentication scopes to use with this package. func DefaultAuthScopes() []string { return []string{ "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/pubsub", } } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/apiv1/path_funcs.go ================================================ // Copyright 2018 Google LLC // // 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 // // https://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. package pubsub // PublisherProjectPath returns the path for the project resource. // // Deprecated: Use // fmt.Sprintf("projects/%s", project) // instead. func PublisherProjectPath(project string) string { return "" + "projects/" + project + "" } // PublisherTopicPath returns the path for the topic resource. // // Deprecated: Use // fmt.Sprintf("projects/%s/topics/%s", project, topic) // instead. func PublisherTopicPath(project, topic string) string { return "" + "projects/" + project + "/topics/" + topic + "" } // SubscriberProjectPath returns the path for the project resource. // // Deprecated: Use // fmt.Sprintf("projects/%s", project) // instead. func SubscriberProjectPath(project string) string { return "" + "projects/" + project + "" } // SubscriberSnapshotPath returns the path for the snapshot resource. // // Deprecated: Use // fmt.Sprintf("projects/%s/snapshots/%s", project, snapshot) // instead. func SubscriberSnapshotPath(project, snapshot string) string { return "" + "projects/" + project + "/snapshots/" + snapshot + "" } // SubscriberSubscriptionPath returns the path for the subscription resource. // // Deprecated: Use // fmt.Sprintf("projects/%s/subscriptions/%s", project, subscription) // instead. func SubscriberSubscriptionPath(project, subscription string) string { return "" + "projects/" + project + "/subscriptions/" + subscription + "" } // SubscriberTopicPath returns the path for the topic resource. // // Deprecated: Use // fmt.Sprintf("projects/%s/topics/%s", project, topic) // instead. func SubscriberTopicPath(project, topic string) string { return "" + "projects/" + project + "/topics/" + topic + "" } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/apiv1/publisher_client.go ================================================ // Copyright 2018 Google LLC // // 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 // // https://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. // AUTO-GENERATED CODE. DO NOT EDIT. package pubsub import ( "math" "time" "cloud.google.com/go/iam" "cloud.google.com/go/internal/version" gax "github.com/googleapis/gax-go" "golang.org/x/net/context" "google.golang.org/api/iterator" "google.golang.org/api/option" "google.golang.org/api/transport" pubsubpb "google.golang.org/genproto/googleapis/pubsub/v1" "google.golang.org/grpc" "google.golang.org/grpc/codes" "google.golang.org/grpc/metadata" ) // PublisherCallOptions contains the retry settings for each method of PublisherClient. type PublisherCallOptions struct { CreateTopic []gax.CallOption UpdateTopic []gax.CallOption Publish []gax.CallOption GetTopic []gax.CallOption ListTopics []gax.CallOption ListTopicSubscriptions []gax.CallOption DeleteTopic []gax.CallOption } func defaultPublisherClientOptions() []option.ClientOption { return []option.ClientOption{ option.WithEndpoint("pubsub.googleapis.com:443"), option.WithScopes(DefaultAuthScopes()...), } } func defaultPublisherCallOptions() *PublisherCallOptions { retry := map[[2]string][]gax.CallOption{ {"default", "idempotent"}: { gax.WithRetry(func() gax.Retryer { return gax.OnCodes([]codes.Code{ codes.DeadlineExceeded, codes.Unavailable, }, gax.Backoff{ Initial: 100 * time.Millisecond, Max: 60000 * time.Millisecond, Multiplier: 1.3, }) }), }, {"messaging", "one_plus_delivery"}: { gax.WithRetry(func() gax.Retryer { return gax.OnCodes([]codes.Code{ codes.Aborted, codes.Canceled, codes.DeadlineExceeded, codes.Internal, codes.ResourceExhausted, codes.Unavailable, codes.Unknown, }, gax.Backoff{ Initial: 100 * time.Millisecond, Max: 60000 * time.Millisecond, Multiplier: 1.3, }) }), }, } return &PublisherCallOptions{ CreateTopic: retry[[2]string{"default", "idempotent"}], UpdateTopic: retry[[2]string{"default", "idempotent"}], Publish: retry[[2]string{"messaging", "one_plus_delivery"}], GetTopic: retry[[2]string{"default", "idempotent"}], ListTopics: retry[[2]string{"default", "idempotent"}], ListTopicSubscriptions: retry[[2]string{"default", "idempotent"}], DeleteTopic: retry[[2]string{"default", "idempotent"}], } } // PublisherClient is a client for interacting with Google Cloud Pub/Sub API. type PublisherClient struct { // The connection to the service. conn *grpc.ClientConn // The gRPC API client. publisherClient pubsubpb.PublisherClient // The call options for this service. CallOptions *PublisherCallOptions // The x-goog-* metadata to be sent with each request. xGoogMetadata metadata.MD } // NewPublisherClient creates a new publisher client. // // The service that an application uses to manipulate topics, and to send // messages to a topic. func NewPublisherClient(ctx context.Context, opts ...option.ClientOption) (*PublisherClient, error) { conn, err := transport.DialGRPC(ctx, append(defaultPublisherClientOptions(), opts...)...) if err != nil { return nil, err } c := &PublisherClient{ conn: conn, CallOptions: defaultPublisherCallOptions(), publisherClient: pubsubpb.NewPublisherClient(conn), } c.SetGoogleClientInfo() return c, nil } // Connection returns the client's connection to the API service. func (c *PublisherClient) Connection() *grpc.ClientConn { return c.conn } // Close closes the connection to the API service. The user should invoke this when // the client is no longer required. func (c *PublisherClient) Close() error { return c.conn.Close() } // SetGoogleClientInfo sets the name and version of the application in // the `x-goog-api-client` header passed on each request. Intended for // use by Google-written clients. func (c *PublisherClient) SetGoogleClientInfo(keyval ...string) { kv := append([]string{"gl-go", version.Go()}, keyval...) kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version) c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...)) } func (c *PublisherClient) SubscriptionIAM(subscription *pubsubpb.Subscription) *iam.Handle { return iam.InternalNewHandle(c.Connection(), subscription.Name) } func (c *PublisherClient) TopicIAM(topic *pubsubpb.Topic) *iam.Handle { return iam.InternalNewHandle(c.Connection(), topic.Name) } // CreateTopic creates the given topic with the given name. func (c *PublisherClient) CreateTopic(ctx context.Context, req *pubsubpb.Topic, opts ...gax.CallOption) (*pubsubpb.Topic, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.CreateTopic[0:len(c.CallOptions.CreateTopic):len(c.CallOptions.CreateTopic)], opts...) var resp *pubsubpb.Topic err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.publisherClient.CreateTopic(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // UpdateTopic updates an existing topic. Note that certain properties of a topic are not // modifiable. Options settings follow the style guide: // NOTE: The style guide requires body: "topic" instead of body: "*". // Keeping the latter for internal consistency in V1, however it should be // corrected in V2. See // https://cloud.google.com/apis/design/standard_methods#update for details. func (c *PublisherClient) UpdateTopic(ctx context.Context, req *pubsubpb.UpdateTopicRequest, opts ...gax.CallOption) (*pubsubpb.Topic, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.UpdateTopic[0:len(c.CallOptions.UpdateTopic):len(c.CallOptions.UpdateTopic)], opts...) var resp *pubsubpb.Topic err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.publisherClient.UpdateTopic(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // Publish adds one or more messages to the topic. Returns NOT_FOUND if the topic // does not exist. The message payload must not be empty; it must contain // either a non-empty data field, or at least one attribute. func (c *PublisherClient) Publish(ctx context.Context, req *pubsubpb.PublishRequest, opts ...gax.CallOption) (*pubsubpb.PublishResponse, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.Publish[0:len(c.CallOptions.Publish):len(c.CallOptions.Publish)], opts...) var resp *pubsubpb.PublishResponse err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.publisherClient.Publish(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // GetTopic gets the configuration of a topic. func (c *PublisherClient) GetTopic(ctx context.Context, req *pubsubpb.GetTopicRequest, opts ...gax.CallOption) (*pubsubpb.Topic, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.GetTopic[0:len(c.CallOptions.GetTopic):len(c.CallOptions.GetTopic)], opts...) var resp *pubsubpb.Topic err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.publisherClient.GetTopic(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // ListTopics lists matching topics. func (c *PublisherClient) ListTopics(ctx context.Context, req *pubsubpb.ListTopicsRequest, opts ...gax.CallOption) *TopicIterator { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.ListTopics[0:len(c.CallOptions.ListTopics):len(c.CallOptions.ListTopics)], opts...) it := &TopicIterator{} it.InternalFetch = func(pageSize int, pageToken string) ([]*pubsubpb.Topic, string, error) { var resp *pubsubpb.ListTopicsResponse req.PageToken = pageToken if pageSize > math.MaxInt32 { req.PageSize = math.MaxInt32 } else { req.PageSize = int32(pageSize) } err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.publisherClient.ListTopics(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, "", err } return resp.Topics, resp.NextPageToken, nil } fetch := func(pageSize int, pageToken string) (string, error) { items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) if err != nil { return "", err } it.items = append(it.items, items...) return nextPageToken, nil } it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) return it } // ListTopicSubscriptions lists the name of the subscriptions for this topic. func (c *PublisherClient) ListTopicSubscriptions(ctx context.Context, req *pubsubpb.ListTopicSubscriptionsRequest, opts ...gax.CallOption) *StringIterator { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.ListTopicSubscriptions[0:len(c.CallOptions.ListTopicSubscriptions):len(c.CallOptions.ListTopicSubscriptions)], opts...) it := &StringIterator{} it.InternalFetch = func(pageSize int, pageToken string) ([]string, string, error) { var resp *pubsubpb.ListTopicSubscriptionsResponse req.PageToken = pageToken if pageSize > math.MaxInt32 { req.PageSize = math.MaxInt32 } else { req.PageSize = int32(pageSize) } err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.publisherClient.ListTopicSubscriptions(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, "", err } return resp.Subscriptions, resp.NextPageToken, nil } fetch := func(pageSize int, pageToken string) (string, error) { items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) if err != nil { return "", err } it.items = append(it.items, items...) return nextPageToken, nil } it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) return it } // DeleteTopic deletes the topic with the given name. Returns NOT_FOUND if the topic // does not exist. After a topic is deleted, a new topic may be created with // the same name; this is an entirely new topic with none of the old // configuration or subscriptions. Existing subscriptions to this topic are // not deleted, but their topic field is set to _deleted-topic_. func (c *PublisherClient) DeleteTopic(ctx context.Context, req *pubsubpb.DeleteTopicRequest, opts ...gax.CallOption) error { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.DeleteTopic[0:len(c.CallOptions.DeleteTopic):len(c.CallOptions.DeleteTopic)], opts...) err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error _, err = c.publisherClient.DeleteTopic(ctx, req, settings.GRPC...) return err }, opts...) return err } // StringIterator manages a stream of string. type StringIterator struct { items []string pageInfo *iterator.PageInfo nextFunc func() error // InternalFetch is for use by the Google Cloud Libraries only. // It is not part of the stable interface of this package. // // InternalFetch returns results from a single call to the underlying RPC. // The number of results is no greater than pageSize. // If there are no more results, nextPageToken is empty and err is nil. InternalFetch func(pageSize int, pageToken string) (results []string, nextPageToken string, err error) } // PageInfo supports pagination. See the google.golang.org/api/iterator package for details. func (it *StringIterator) PageInfo() *iterator.PageInfo { return it.pageInfo } // Next returns the next result. Its second return value is iterator.Done if there are no more // results. Once Next returns Done, all subsequent calls will return Done. func (it *StringIterator) Next() (string, error) { var item string if err := it.nextFunc(); err != nil { return item, err } item = it.items[0] it.items = it.items[1:] return item, nil } func (it *StringIterator) bufLen() int { return len(it.items) } func (it *StringIterator) takeBuf() interface{} { b := it.items it.items = nil return b } // TopicIterator manages a stream of *pubsubpb.Topic. type TopicIterator struct { items []*pubsubpb.Topic pageInfo *iterator.PageInfo nextFunc func() error // InternalFetch is for use by the Google Cloud Libraries only. // It is not part of the stable interface of this package. // // InternalFetch returns results from a single call to the underlying RPC. // The number of results is no greater than pageSize. // If there are no more results, nextPageToken is empty and err is nil. InternalFetch func(pageSize int, pageToken string) (results []*pubsubpb.Topic, nextPageToken string, err error) } // PageInfo supports pagination. See the google.golang.org/api/iterator package for details. func (it *TopicIterator) PageInfo() *iterator.PageInfo { return it.pageInfo } // Next returns the next result. Its second return value is iterator.Done if there are no more // results. Once Next returns Done, all subsequent calls will return Done. func (it *TopicIterator) Next() (*pubsubpb.Topic, error) { var item *pubsubpb.Topic if err := it.nextFunc(); err != nil { return item, err } item = it.items[0] it.items = it.items[1:] return item, nil } func (it *TopicIterator) bufLen() int { return len(it.items) } func (it *TopicIterator) takeBuf() interface{} { b := it.items it.items = nil return b } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/apiv1/subscriber_client.go ================================================ // Copyright 2018 Google LLC // // 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 // // https://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. // AUTO-GENERATED CODE. DO NOT EDIT. package pubsub import ( "math" "time" "cloud.google.com/go/iam" "cloud.google.com/go/internal/version" gax "github.com/googleapis/gax-go" "golang.org/x/net/context" "google.golang.org/api/iterator" "google.golang.org/api/option" "google.golang.org/api/transport" pubsubpb "google.golang.org/genproto/googleapis/pubsub/v1" "google.golang.org/grpc" "google.golang.org/grpc/codes" "google.golang.org/grpc/metadata" ) // SubscriberCallOptions contains the retry settings for each method of SubscriberClient. type SubscriberCallOptions struct { CreateSubscription []gax.CallOption GetSubscription []gax.CallOption UpdateSubscription []gax.CallOption ListSubscriptions []gax.CallOption DeleteSubscription []gax.CallOption ModifyAckDeadline []gax.CallOption Acknowledge []gax.CallOption Pull []gax.CallOption StreamingPull []gax.CallOption ModifyPushConfig []gax.CallOption ListSnapshots []gax.CallOption CreateSnapshot []gax.CallOption UpdateSnapshot []gax.CallOption DeleteSnapshot []gax.CallOption Seek []gax.CallOption } func defaultSubscriberClientOptions() []option.ClientOption { return []option.ClientOption{ option.WithEndpoint("pubsub.googleapis.com:443"), option.WithScopes(DefaultAuthScopes()...), } } func defaultSubscriberCallOptions() *SubscriberCallOptions { retry := map[[2]string][]gax.CallOption{ {"default", "idempotent"}: { gax.WithRetry(func() gax.Retryer { return gax.OnCodes([]codes.Code{ codes.DeadlineExceeded, codes.Unavailable, }, gax.Backoff{ Initial: 100 * time.Millisecond, Max: 60000 * time.Millisecond, Multiplier: 1.3, }) }), }, {"messaging", "pull"}: { gax.WithRetry(func() gax.Retryer { return gax.OnCodes([]codes.Code{ codes.Canceled, codes.DeadlineExceeded, codes.Internal, codes.ResourceExhausted, codes.Unavailable, }, gax.Backoff{ Initial: 100 * time.Millisecond, Max: 60000 * time.Millisecond, Multiplier: 1.3, }) }), }, {"streaming_messaging", "pull"}: { gax.WithRetry(func() gax.Retryer { return gax.OnCodes([]codes.Code{ codes.Canceled, codes.DeadlineExceeded, codes.Internal, codes.ResourceExhausted, codes.Unavailable, }, gax.Backoff{ Initial: 100 * time.Millisecond, Max: 60000 * time.Millisecond, Multiplier: 1.3, }) }), }, } return &SubscriberCallOptions{ CreateSubscription: retry[[2]string{"default", "idempotent"}], GetSubscription: retry[[2]string{"default", "idempotent"}], UpdateSubscription: retry[[2]string{"default", "idempotent"}], ListSubscriptions: retry[[2]string{"default", "idempotent"}], DeleteSubscription: retry[[2]string{"default", "idempotent"}], ModifyAckDeadline: retry[[2]string{"default", "non_idempotent"}], Acknowledge: retry[[2]string{"messaging", "non_idempotent"}], Pull: retry[[2]string{"messaging", "pull"}], StreamingPull: retry[[2]string{"streaming_messaging", "pull"}], ModifyPushConfig: retry[[2]string{"default", "non_idempotent"}], ListSnapshots: retry[[2]string{"default", "idempotent"}], CreateSnapshot: retry[[2]string{"default", "idempotent"}], UpdateSnapshot: retry[[2]string{"default", "idempotent"}], DeleteSnapshot: retry[[2]string{"default", "idempotent"}], Seek: retry[[2]string{"default", "non_idempotent"}], } } // SubscriberClient is a client for interacting with Google Cloud Pub/Sub API. type SubscriberClient struct { // The connection to the service. conn *grpc.ClientConn // The gRPC API client. subscriberClient pubsubpb.SubscriberClient // The call options for this service. CallOptions *SubscriberCallOptions // The x-goog-* metadata to be sent with each request. xGoogMetadata metadata.MD } // NewSubscriberClient creates a new subscriber client. // // The service that an application uses to manipulate subscriptions and to // consume messages from a subscription via the Pull method. func NewSubscriberClient(ctx context.Context, opts ...option.ClientOption) (*SubscriberClient, error) { conn, err := transport.DialGRPC(ctx, append(defaultSubscriberClientOptions(), opts...)...) if err != nil { return nil, err } c := &SubscriberClient{ conn: conn, CallOptions: defaultSubscriberCallOptions(), subscriberClient: pubsubpb.NewSubscriberClient(conn), } c.SetGoogleClientInfo() return c, nil } // Connection returns the client's connection to the API service. func (c *SubscriberClient) Connection() *grpc.ClientConn { return c.conn } // Close closes the connection to the API service. The user should invoke this when // the client is no longer required. func (c *SubscriberClient) Close() error { return c.conn.Close() } // SetGoogleClientInfo sets the name and version of the application in // the `x-goog-api-client` header passed on each request. Intended for // use by Google-written clients. func (c *SubscriberClient) SetGoogleClientInfo(keyval ...string) { kv := append([]string{"gl-go", version.Go()}, keyval...) kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version) c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...)) } func (c *SubscriberClient) SubscriptionIAM(subscription *pubsubpb.Subscription) *iam.Handle { return iam.InternalNewHandle(c.Connection(), subscription.Name) } func (c *SubscriberClient) TopicIAM(topic *pubsubpb.Topic) *iam.Handle { return iam.InternalNewHandle(c.Connection(), topic.Name) } // CreateSubscription creates a subscription to a given topic. // If the subscription already exists, returns ALREADY_EXISTS. // If the corresponding topic doesn't exist, returns NOT_FOUND. // // If the name is not provided in the request, the server will assign a random // name for this subscription on the same project as the topic, conforming // to the // resource name format (at https://cloud.google.com/pubsub/docs/overview#names). // The generated name is populated in the returned Subscription object. // Note that for REST API requests, you must specify a name in the request. func (c *SubscriberClient) CreateSubscription(ctx context.Context, req *pubsubpb.Subscription, opts ...gax.CallOption) (*pubsubpb.Subscription, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.CreateSubscription[0:len(c.CallOptions.CreateSubscription):len(c.CallOptions.CreateSubscription)], opts...) var resp *pubsubpb.Subscription err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.subscriberClient.CreateSubscription(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // GetSubscription gets the configuration details of a subscription. func (c *SubscriberClient) GetSubscription(ctx context.Context, req *pubsubpb.GetSubscriptionRequest, opts ...gax.CallOption) (*pubsubpb.Subscription, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.GetSubscription[0:len(c.CallOptions.GetSubscription):len(c.CallOptions.GetSubscription)], opts...) var resp *pubsubpb.Subscription err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.subscriberClient.GetSubscription(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // UpdateSubscription updates an existing subscription. Note that certain properties of a // subscription, such as its topic, are not modifiable. // NOTE: The style guide requires body: "subscription" instead of body: "*". // Keeping the latter for internal consistency in V1, however it should be // corrected in V2. See // https://cloud.google.com/apis/design/standard_methods#update for details. func (c *SubscriberClient) UpdateSubscription(ctx context.Context, req *pubsubpb.UpdateSubscriptionRequest, opts ...gax.CallOption) (*pubsubpb.Subscription, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.UpdateSubscription[0:len(c.CallOptions.UpdateSubscription):len(c.CallOptions.UpdateSubscription)], opts...) var resp *pubsubpb.Subscription err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.subscriberClient.UpdateSubscription(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // ListSubscriptions lists matching subscriptions. func (c *SubscriberClient) ListSubscriptions(ctx context.Context, req *pubsubpb.ListSubscriptionsRequest, opts ...gax.CallOption) *SubscriptionIterator { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.ListSubscriptions[0:len(c.CallOptions.ListSubscriptions):len(c.CallOptions.ListSubscriptions)], opts...) it := &SubscriptionIterator{} it.InternalFetch = func(pageSize int, pageToken string) ([]*pubsubpb.Subscription, string, error) { var resp *pubsubpb.ListSubscriptionsResponse req.PageToken = pageToken if pageSize > math.MaxInt32 { req.PageSize = math.MaxInt32 } else { req.PageSize = int32(pageSize) } err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.subscriberClient.ListSubscriptions(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, "", err } return resp.Subscriptions, resp.NextPageToken, nil } fetch := func(pageSize int, pageToken string) (string, error) { items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) if err != nil { return "", err } it.items = append(it.items, items...) return nextPageToken, nil } it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) return it } // DeleteSubscription deletes an existing subscription. All messages retained in the subscription // are immediately dropped. Calls to Pull after deletion will return // NOT_FOUND. After a subscription is deleted, a new one may be created with // the same name, but the new one has no association with the old // subscription or its topic unless the same topic is specified. func (c *SubscriberClient) DeleteSubscription(ctx context.Context, req *pubsubpb.DeleteSubscriptionRequest, opts ...gax.CallOption) error { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.DeleteSubscription[0:len(c.CallOptions.DeleteSubscription):len(c.CallOptions.DeleteSubscription)], opts...) err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error _, err = c.subscriberClient.DeleteSubscription(ctx, req, settings.GRPC...) return err }, opts...) return err } // ModifyAckDeadline modifies the ack deadline for a specific message. This method is useful // to indicate that more time is needed to process a message by the // subscriber, or to make the message available for redelivery if the // processing was interrupted. Note that this does not modify the // subscription-level ackDeadlineSeconds used for subsequent messages. func (c *SubscriberClient) ModifyAckDeadline(ctx context.Context, req *pubsubpb.ModifyAckDeadlineRequest, opts ...gax.CallOption) error { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.ModifyAckDeadline[0:len(c.CallOptions.ModifyAckDeadline):len(c.CallOptions.ModifyAckDeadline)], opts...) err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error _, err = c.subscriberClient.ModifyAckDeadline(ctx, req, settings.GRPC...) return err }, opts...) return err } // Acknowledge acknowledges the messages associated with the ack_ids in the // AcknowledgeRequest. The Pub/Sub system can remove the relevant messages // from the subscription. // // Acknowledging a message whose ack deadline has expired may succeed, // but such a message may be redelivered later. Acknowledging a message more // than once will not result in an error. func (c *SubscriberClient) Acknowledge(ctx context.Context, req *pubsubpb.AcknowledgeRequest, opts ...gax.CallOption) error { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.Acknowledge[0:len(c.CallOptions.Acknowledge):len(c.CallOptions.Acknowledge)], opts...) err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error _, err = c.subscriberClient.Acknowledge(ctx, req, settings.GRPC...) return err }, opts...) return err } // Pull pulls messages from the server. Returns an empty list if there are no // messages available in the backlog. The server may return UNAVAILABLE if // there are too many concurrent pull requests pending for the given // subscription. func (c *SubscriberClient) Pull(ctx context.Context, req *pubsubpb.PullRequest, opts ...gax.CallOption) (*pubsubpb.PullResponse, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.Pull[0:len(c.CallOptions.Pull):len(c.CallOptions.Pull)], opts...) var resp *pubsubpb.PullResponse err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.subscriberClient.Pull(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // StreamingPull (EXPERIMENTAL) StreamingPull is an experimental feature. This RPC will // respond with UNIMPLEMENTED errors unless you have been invited to test // this feature. Contact cloud-pubsub@google.com with any questions. // // Establishes a stream with the server, which sends messages down to the // client. The client streams acknowledgements and ack deadline modifications // back to the server. The server will close the stream and return the status // on any error. The server may close the stream with status OK to reassign // server-side resources, in which case, the client should re-establish the // stream. UNAVAILABLE may also be returned in the case of a transient error // (e.g., a server restart). These should also be retried by the client. Flow // control can be achieved by configuring the underlying RPC channel. func (c *SubscriberClient) StreamingPull(ctx context.Context, opts ...gax.CallOption) (pubsubpb.Subscriber_StreamingPullClient, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.StreamingPull[0:len(c.CallOptions.StreamingPull):len(c.CallOptions.StreamingPull)], opts...) var resp pubsubpb.Subscriber_StreamingPullClient err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.subscriberClient.StreamingPull(ctx, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // ModifyPushConfig modifies the PushConfig for a specified subscription. // // This may be used to change a push subscription to a pull one (signified by // an empty PushConfig) or vice versa, or change the endpoint URL and other // attributes of a push subscription. Messages will accumulate for delivery // continuously through the call regardless of changes to the PushConfig. func (c *SubscriberClient) ModifyPushConfig(ctx context.Context, req *pubsubpb.ModifyPushConfigRequest, opts ...gax.CallOption) error { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.ModifyPushConfig[0:len(c.CallOptions.ModifyPushConfig):len(c.CallOptions.ModifyPushConfig)], opts...) err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error _, err = c.subscriberClient.ModifyPushConfig(ctx, req, settings.GRPC...) return err }, opts...) return err } // ListSnapshots lists the existing snapshots. func (c *SubscriberClient) ListSnapshots(ctx context.Context, req *pubsubpb.ListSnapshotsRequest, opts ...gax.CallOption) *SnapshotIterator { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.ListSnapshots[0:len(c.CallOptions.ListSnapshots):len(c.CallOptions.ListSnapshots)], opts...) it := &SnapshotIterator{} it.InternalFetch = func(pageSize int, pageToken string) ([]*pubsubpb.Snapshot, string, error) { var resp *pubsubpb.ListSnapshotsResponse req.PageToken = pageToken if pageSize > math.MaxInt32 { req.PageSize = math.MaxInt32 } else { req.PageSize = int32(pageSize) } err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.subscriberClient.ListSnapshots(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, "", err } return resp.Snapshots, resp.NextPageToken, nil } fetch := func(pageSize int, pageToken string) (string, error) { items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) if err != nil { return "", err } it.items = append(it.items, items...) return nextPageToken, nil } it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) return it } // CreateSnapshot creates a snapshot from the requested subscription. // If the snapshot already exists, returns ALREADY_EXISTS. // If the requested subscription doesn't exist, returns NOT_FOUND. // // If the name is not provided in the request, the server will assign a random // name for this snapshot on the same project as the subscription, conforming // to the // resource name format (at https://cloud.google.com/pubsub/docs/overview#names). // The generated name is populated in the returned Snapshot object. // Note that for REST API requests, you must specify a name in the request. func (c *SubscriberClient) CreateSnapshot(ctx context.Context, req *pubsubpb.CreateSnapshotRequest, opts ...gax.CallOption) (*pubsubpb.Snapshot, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.CreateSnapshot[0:len(c.CallOptions.CreateSnapshot):len(c.CallOptions.CreateSnapshot)], opts...) var resp *pubsubpb.Snapshot err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.subscriberClient.CreateSnapshot(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // UpdateSnapshot updates an existing snapshot. Note that certain properties of a snapshot // are not modifiable. // NOTE: The style guide requires body: "snapshot" instead of body: "*". // Keeping the latter for internal consistency in V1, however it should be // corrected in V2. See // https://cloud.google.com/apis/design/standard_methods#update for details. func (c *SubscriberClient) UpdateSnapshot(ctx context.Context, req *pubsubpb.UpdateSnapshotRequest, opts ...gax.CallOption) (*pubsubpb.Snapshot, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.UpdateSnapshot[0:len(c.CallOptions.UpdateSnapshot):len(c.CallOptions.UpdateSnapshot)], opts...) var resp *pubsubpb.Snapshot err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.subscriberClient.UpdateSnapshot(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // DeleteSnapshot removes an existing snapshot. All messages retained in the snapshot // are immediately dropped. After a snapshot is deleted, a new one may be // created with the same name, but the new one has no association with the old // snapshot or its subscription, unless the same subscription is specified. func (c *SubscriberClient) DeleteSnapshot(ctx context.Context, req *pubsubpb.DeleteSnapshotRequest, opts ...gax.CallOption) error { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.DeleteSnapshot[0:len(c.CallOptions.DeleteSnapshot):len(c.CallOptions.DeleteSnapshot)], opts...) err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error _, err = c.subscriberClient.DeleteSnapshot(ctx, req, settings.GRPC...) return err }, opts...) return err } // Seek seeks an existing subscription to a point in time or to a given snapshot, // whichever is provided in the request. func (c *SubscriberClient) Seek(ctx context.Context, req *pubsubpb.SeekRequest, opts ...gax.CallOption) (*pubsubpb.SeekResponse, error) { ctx = insertMetadata(ctx, c.xGoogMetadata) opts = append(c.CallOptions.Seek[0:len(c.CallOptions.Seek):len(c.CallOptions.Seek)], opts...) var resp *pubsubpb.SeekResponse err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { var err error resp, err = c.subscriberClient.Seek(ctx, req, settings.GRPC...) return err }, opts...) if err != nil { return nil, err } return resp, nil } // SnapshotIterator manages a stream of *pubsubpb.Snapshot. type SnapshotIterator struct { items []*pubsubpb.Snapshot pageInfo *iterator.PageInfo nextFunc func() error // InternalFetch is for use by the Google Cloud Libraries only. // It is not part of the stable interface of this package. // // InternalFetch returns results from a single call to the underlying RPC. // The number of results is no greater than pageSize. // If there are no more results, nextPageToken is empty and err is nil. InternalFetch func(pageSize int, pageToken string) (results []*pubsubpb.Snapshot, nextPageToken string, err error) } // PageInfo supports pagination. See the google.golang.org/api/iterator package for details. func (it *SnapshotIterator) PageInfo() *iterator.PageInfo { return it.pageInfo } // Next returns the next result. Its second return value is iterator.Done if there are no more // results. Once Next returns Done, all subsequent calls will return Done. func (it *SnapshotIterator) Next() (*pubsubpb.Snapshot, error) { var item *pubsubpb.Snapshot if err := it.nextFunc(); err != nil { return item, err } item = it.items[0] it.items = it.items[1:] return item, nil } func (it *SnapshotIterator) bufLen() int { return len(it.items) } func (it *SnapshotIterator) takeBuf() interface{} { b := it.items it.items = nil return b } // SubscriptionIterator manages a stream of *pubsubpb.Subscription. type SubscriptionIterator struct { items []*pubsubpb.Subscription pageInfo *iterator.PageInfo nextFunc func() error // InternalFetch is for use by the Google Cloud Libraries only. // It is not part of the stable interface of this package. // // InternalFetch returns results from a single call to the underlying RPC. // The number of results is no greater than pageSize. // If there are no more results, nextPageToken is empty and err is nil. InternalFetch func(pageSize int, pageToken string) (results []*pubsubpb.Subscription, nextPageToken string, err error) } // PageInfo supports pagination. See the google.golang.org/api/iterator package for details. func (it *SubscriptionIterator) PageInfo() *iterator.PageInfo { return it.pageInfo } // Next returns the next result. Its second return value is iterator.Done if there are no more // results. Once Next returns Done, all subsequent calls will return Done. func (it *SubscriptionIterator) Next() (*pubsubpb.Subscription, error) { var item *pubsubpb.Subscription if err := it.nextFunc(); err != nil { return item, err } item = it.items[0] it.items = it.items[1:] return item, nil } func (it *SubscriptionIterator) bufLen() int { return len(it.items) } func (it *SubscriptionIterator) takeBuf() interface{} { b := it.items it.items = nil return b } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/doc.go ================================================ // Copyright 2016 Google Inc. 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. /* Package pubsub provides an easy way to publish and receive Google Cloud Pub/Sub messages, hiding the the details of the underlying server RPCs. Google Cloud Pub/Sub is a many-to-many, asynchronous messaging system that decouples senders and receivers. Note: This package is in beta. Some backwards-incompatible changes may occur. More information about Google Cloud Pub/Sub is available at https://cloud.google.com/pubsub/docs See https://godoc.org/cloud.google.com/go for authentication, timeouts, connection pooling and similar aspects of this package. Publishing Google Cloud Pub/Sub messages are published to topics. Topics may be created using the pubsub package like so: topic, err := pubsubClient.CreateTopic(context.Background(), "topic-name") Messages may then be published to a topic: res := topic.Publish(ctx, &pubsub.Message{Data: []byte("payload")}) Publish queues the message for publishing and returns immediately. When enough messages have accumulated, or enough time has elapsed, the batch of messages is sent to the Pub/Sub service. Publish returns a PublishResult, which behaves like a future: its Get method blocks until the message has been sent to the service. The first time you call Publish on a topic, goroutines are started in the background. To clean up these goroutines, call Stop: topic.Stop() Receiving To receive messages published to a topic, clients create subscriptions to the topic. There may be more than one subscription per topic; each message that is published to the topic will be delivered to all of its subscriptions. Subsciptions may be created like so: sub, err := pubsubClient.CreateSubscription(context.Background(), "sub-name", pubsub.SubscriptionConfig{Topic: topic}) Messages are then consumed from a subscription via callback. err := sub.Receive(context.Background(), func(ctx context.Context, m *Message) { log.Printf("Got message: %s", m.Data) m.Ack() }) if err != nil { // Handle error. } The callback is invoked concurrently by multiple goroutines, maximizing throughput. To terminate a call to Receive, cancel its context. Once client code has processed the message, it must call Message.Ack, otherwise the message will eventually be redelivered. As an optimization, if the client cannot or doesn't want to process the message, it can call Message.Nack to speed redelivery. For more information and configuration options, see "Deadlines" below. Note: It is possible for Messages to be redelivered, even if Message.Ack has been called. Client code must be robust to multiple deliveries of messages. Deadlines The default pubsub deadlines are suitable for most use cases, but may be overridden. This section describes the tradeoffs that should be considered when overriding the defaults. Behind the scenes, each message returned by the Pub/Sub server has an associated lease, known as an "ACK deadline". Unless a message is acknowledged within the ACK deadline, or the client requests that the ACK deadline be extended, the message will become elegible for redelivery. As a convenience, the pubsub package will automatically extend deadlines until either: * Message.Ack or Message.Nack is called, or * the "MaxExtension" period elapses from the time the message is fetched from the server. The initial ACK deadline given to each messages defaults to 10 seconds, but may be overridden during subscription creation. Selecting an ACK deadline is a tradeoff between message redelivery latency and RPC volume. If the pubsub package fails to acknowledge or extend a message (e.g. due to unexpected termination of the process), a shorter ACK deadline will generally result in faster message redelivery by the Pub/Sub system. However, a short ACK deadline may also increase the number of deadline extension RPCs that the pubsub package sends to the server. The default max extension period is DefaultReceiveSettings.MaxExtension, and can be overridden by setting Subscription.ReceiveSettings.MaxExtension. Selecting a max extension period is a tradeoff between the speed at which client code must process messages, and the redelivery delay if messages fail to be acknowledged (e.g. because client code neglects to do so). Using a large MaxExtension increases the available time for client code to process messages. However, if the client code neglects to call Message.Ack/Nack, a large MaxExtension will increase the delay before the message is redelivered. Slow Message Processing For use cases where message processing exceeds 30 minutes, we recommend using the base client in a pull model, since long-lived streams are periodically killed by firewalls. See the example at https://godoc.org/cloud.google.com/go/pubsub/apiv1#example-SubscriberClient-Pull-LengthyClientProcessing */ package pubsub // import "cloud.google.com/go/pubsub" ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/flow_controller.go ================================================ // Copyright 2017 Google Inc. 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. package pubsub import ( "golang.org/x/net/context" "golang.org/x/sync/semaphore" ) // flowController implements flow control for Subscription.Receive. type flowController struct { maxSize int // max total size of messages semCount, semSize *semaphore.Weighted // enforces max number and size of messages } // newFlowController creates a new flowController that ensures no more than // maxCount messages or maxSize bytes are outstanding at once. If maxCount or // maxSize is < 1, then an unlimited number of messages or bytes is permitted, // respectively. func newFlowController(maxCount, maxSize int) *flowController { fc := &flowController{ maxSize: maxSize, semCount: nil, semSize: nil, } if maxCount > 0 { fc.semCount = semaphore.NewWeighted(int64(maxCount)) } if maxSize > 0 { fc.semSize = semaphore.NewWeighted(int64(maxSize)) } return fc } // acquire blocks until one message of size bytes can proceed or ctx is done. // It returns nil in the first case, or ctx.Err() in the second. // // acquire allows large messages to proceed by treating a size greater than maxSize // as if it were equal to maxSize. func (f *flowController) acquire(ctx context.Context, size int) error { if f.semCount != nil { if err := f.semCount.Acquire(ctx, 1); err != nil { return err } } if f.semSize != nil { if err := f.semSize.Acquire(ctx, f.bound(size)); err != nil { if f.semCount != nil { f.semCount.Release(1) } return err } } return nil } // tryAcquire returns false if acquire would block. Otherwise, it behaves like // acquire and returns true. // // tryAcquire allows large messages to proceed by treating a size greater than // maxSize as if it were equal to maxSize. func (f *flowController) tryAcquire(size int) bool { if f.semCount != nil { if !f.semCount.TryAcquire(1) { return false } } if f.semSize != nil { if !f.semSize.TryAcquire(f.bound(size)) { if f.semCount != nil { f.semCount.Release(1) } return false } } return true } // release notes that one message of size bytes is no longer outstanding. func (f *flowController) release(size int) { if f.semCount != nil { f.semCount.Release(1) } if f.semSize != nil { f.semSize.Release(f.bound(size)) } } func (f *flowController) bound(size int) int64 { if size > f.maxSize { return int64(f.maxSize) } return int64(size) } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/go18.go ================================================ // Copyright 2018 Google Inc. 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. // +build go1.8 package pubsub import ( "log" "sync" "go.opencensus.io/plugin/ocgrpc" "go.opencensus.io/stats" "go.opencensus.io/stats/view" "go.opencensus.io/tag" "golang.org/x/net/context" "google.golang.org/api/option" "google.golang.org/grpc" ) func openCensusOptions() []option.ClientOption { return []option.ClientOption{ option.WithGRPCDialOption(grpc.WithStatsHandler(&ocgrpc.ClientHandler{})), } } var subscriptionKey tag.Key func init() { var err error if subscriptionKey, err = tag.NewKey("subscription"); err != nil { log.Fatal("cannot create 'subscription' key") } } const statsPrefix = "cloud.google.com/go/pubsub/" var ( // PullCount is a measure of the number of messages pulled. // It is EXPERIMENTAL and subject to change or removal without notice. PullCount = stats.Int64(statsPrefix+"pull_count", "Number of PubSub messages pulled", stats.UnitNone) // AckCount is a measure of the number of messages acked. // It is EXPERIMENTAL and subject to change or removal without notice. AckCount = stats.Int64(statsPrefix+"ack_count", "Number of PubSub messages acked", stats.UnitNone) // NackCount is a measure of the number of messages nacked. // It is EXPERIMENTAL and subject to change or removal without notice. NackCount = stats.Int64(statsPrefix+"nack_count", "Number of PubSub messages nacked", stats.UnitNone) // ModAckCount is a measure of the number of messages whose ack-deadline was modified. // It is EXPERIMENTAL and subject to change or removal without notice. ModAckCount = stats.Int64(statsPrefix+"mod_ack_count", "Number of ack-deadlines modified", stats.UnitNone) // StreamOpenCount is a measure of the number of times a streaming-pull stream was opened. // It is EXPERIMENTAL and subject to change or removal without notice. StreamOpenCount = stats.Int64(statsPrefix+"stream_open_count", "Number of calls opening a new streaming pull", stats.UnitNone) // StreamRetryCount is a measure of the number of times a streaming-pull operation was retried. // It is EXPERIMENTAL and subject to change or removal without notice. StreamRetryCount = stats.Int64(statsPrefix+"stream_retry_count", "Number of retries of a stream send or receive", stats.UnitNone) // StreamRequestCount is a measure of the number of requests sent on a streaming-pull stream. // It is EXPERIMENTAL and subject to change or removal without notice. StreamRequestCount = stats.Int64(statsPrefix+"stream_request_count", "Number gRPC StreamingPull request messages sent", stats.UnitNone) // StreamResponseCount is a measure of the number of responses received on a streaming-pull stream. // It is EXPERIMENTAL and subject to change or removal without notice. StreamResponseCount = stats.Int64(statsPrefix+"stream_response_count", "Number of gRPC StreamingPull response messages received", stats.UnitNone) // PullCountView is a cumulative sum of PullCount. // It is EXPERIMENTAL and subject to change or removal without notice. PullCountView *view.View // AckCountView is a cumulative sum of AckCount. // It is EXPERIMENTAL and subject to change or removal without notice. AckCountView *view.View // NackCountView is a cumulative sum of NackCount. // It is EXPERIMENTAL and subject to change or removal without notice. NackCountView *view.View // ModAckCountView is a cumulative sum of ModAckCount. // It is EXPERIMENTAL and subject to change or removal without notice. ModAckCountView *view.View // StreamOpenCountView is a cumulative sum of StreamOpenCount. // It is EXPERIMENTAL and subject to change or removal without notice. StreamOpenCountView *view.View // StreamRetryCountView is a cumulative sum of StreamRetryCount. // It is EXPERIMENTAL and subject to change or removal without notice. StreamRetryCountView *view.View // StreamRequestCountView is a cumulative sum of StreamRequestCount. // It is EXPERIMENTAL and subject to change or removal without notice. StreamRequestCountView *view.View // StreamResponseCountView is a cumulative sum of StreamResponseCount. // It is EXPERIMENTAL and subject to change or removal without notice. StreamResponseCountView *view.View ) func init() { PullCountView = countView(PullCount) AckCountView = countView(AckCount) NackCountView = countView(NackCount) ModAckCountView = countView(ModAckCount) StreamOpenCountView = countView(StreamOpenCount) StreamRetryCountView = countView(StreamRetryCount) StreamRequestCountView = countView(StreamRequestCount) StreamResponseCountView = countView(StreamResponseCount) } func countView(m *stats.Int64Measure) *view.View { return &view.View{ Name: m.Name(), Description: m.Description(), TagKeys: []tag.Key{subscriptionKey}, Measure: m, Aggregation: view.Sum(), } } var logOnce sync.Once func withSubscriptionKey(ctx context.Context, subName string) context.Context { ctx, err := tag.New(ctx, tag.Upsert(subscriptionKey, subName)) if err != nil { logOnce.Do(func() { log.Printf("pubsub: error creating tag map: %v", err) }) } return ctx } func recordStat(ctx context.Context, m *stats.Int64Measure, n int64) { stats.Record(ctx, m.M(n)) } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/internal/distribution/distribution.go ================================================ // Copyright 2017 Google Inc. 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. package distribution import ( "log" "math" "sort" "sync/atomic" ) // D is a distribution. Methods of D can be called concurrently by multiple // goroutines. type D struct { buckets []uint64 } // New creates a new distribution capable of holding values from 0 to n-1. func New(n int) *D { return &D{ buckets: make([]uint64, n), } } // Record records value v to the distribution. // To help with distributions with long tails, if v is larger than the maximum value, // Record records the maximum value instead. // If v is negative, Record panics. func (d *D) Record(v int) { if v < 0 { log.Panicf("Record: value out of range: %d", v) } else if v >= len(d.buckets) { v = len(d.buckets) - 1 } atomic.AddUint64(&d.buckets[v], 1) } // Percentile computes the p-th percentile of the distribution where // p is between 0 and 1. func (d *D) Percentile(p float64) int { // NOTE: This implementation uses the nearest-rank method. // https://en.wikipedia.org/wiki/Percentile#The_nearest-rank_method if p < 0 || p > 1 { log.Panicf("Percentile: percentile out of range: %f", p) } bucketSums := make([]uint64, len(d.buckets)) var sum uint64 for i := range bucketSums { sum += atomic.LoadUint64(&d.buckets[i]) bucketSums[i] = sum } total := bucketSums[len(bucketSums)-1] target := uint64(math.Ceil(float64(total) * p)) return sort.Search(len(bucketSums), func(i int) bool { return bucketSums[i] >= target }) } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/iterator.go ================================================ // Copyright 2016 Google Inc. 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. package pubsub import ( "sync" "time" vkit "cloud.google.com/go/pubsub/apiv1" "cloud.google.com/go/pubsub/internal/distribution" "golang.org/x/net/context" pb "google.golang.org/genproto/googleapis/pubsub/v1" ) // newMessageIterator starts a new streamingMessageIterator. Stop must be called on the messageIterator // when it is no longer needed. // subName is the full name of the subscription to pull messages from. // ctx is the context to use for acking messages and extending message deadlines. func newMessageIterator(ctx context.Context, subc *vkit.SubscriberClient, subName string, po *pullOptions) *streamingMessageIterator { ps := newPullStream(ctx, subc, subName, int32(po.ackDeadline.Seconds())) return newStreamingMessageIterator(ctx, ps, po) } type streamingMessageIterator struct { ctx context.Context po *pullOptions ps *pullStream kaTicker *time.Ticker // keep-alive (deadline extensions) ackTicker *time.Ticker // message acks nackTicker *time.Ticker // message nacks (more frequent than acks) failed chan struct{} // closed on stream error stopped chan struct{} // closed when Stop is called drained chan struct{} // closed when stopped && no more pending messages wg sync.WaitGroup mu sync.Mutex ackTimeDist *distribution.D keepAliveDeadlines map[string]time.Time pendingReq *pb.StreamingPullRequest pendingModAcks map[string]int32 // ack IDs whose ack deadline is to be modified err error // error from stream failure } func newStreamingMessageIterator(ctx context.Context, ps *pullStream, po *pullOptions) *streamingMessageIterator { // TODO: make kaTicker frequency more configurable. (ackDeadline - 5s) is a // reasonable default for now, because the minimum ack period is 10s. This // gives us 5s grace. keepAlivePeriod := po.ackDeadline - 5*time.Second kaTicker := time.NewTicker(keepAlivePeriod) // Ack promptly so users don't lose work if client crashes. ackTicker := time.NewTicker(100 * time.Millisecond) nackTicker := time.NewTicker(100 * time.Millisecond) it := &streamingMessageIterator{ ctx: ctx, ps: ps, po: po, kaTicker: kaTicker, ackTicker: ackTicker, nackTicker: nackTicker, failed: make(chan struct{}), stopped: make(chan struct{}), drained: make(chan struct{}), ackTimeDist: distribution.New(int(maxAckDeadline/time.Second) + 1), keepAliveDeadlines: map[string]time.Time{}, pendingReq: &pb.StreamingPullRequest{}, pendingModAcks: map[string]int32{}, } it.wg.Add(1) go it.sender() return it } // Subscription.receive will call stop on its messageIterator when finished with it. // Stop will block until Done has been called on all Messages that have been // returned by Next, or until the context with which the messageIterator was created // is cancelled or exceeds its deadline. func (it *streamingMessageIterator) stop() { it.mu.Lock() select { case <-it.stopped: default: close(it.stopped) } it.checkDrained() it.mu.Unlock() it.wg.Wait() } // checkDrained closes the drained channel if the iterator has been stopped and all // pending messages have either been n/acked or expired. // // Called with the lock held. func (it *streamingMessageIterator) checkDrained() { select { case <-it.drained: return default: } select { case <-it.stopped: if len(it.keepAliveDeadlines) == 0 { close(it.drained) } default: } } // Called when a message is acked/nacked. func (it *streamingMessageIterator) done(ackID string, ack bool, receiveTime time.Time) { it.ackTimeDist.Record(int(time.Since(receiveTime) / time.Second)) it.mu.Lock() defer it.mu.Unlock() delete(it.keepAliveDeadlines, ackID) if ack { it.pendingReq.AckIds = append(it.pendingReq.AckIds, ackID) } else { it.pendingModAcks[ackID] = 0 // Nack indicated by modifying the deadline to zero. } it.checkDrained() } // fail is called when a stream method returns a permanent error. func (it *streamingMessageIterator) fail(err error) { it.mu.Lock() if it.err == nil { it.err = err close(it.failed) } it.mu.Unlock() } // receive makes a call to the stream's Recv method and returns // its messages. func (it *streamingMessageIterator) receive() ([]*Message, error) { // Stop retrieving messages if the context is done, the stream // failed, or the iterator's Stop method was called. select { case <-it.ctx.Done(): return nil, it.ctx.Err() default: } it.mu.Lock() err := it.err it.mu.Unlock() if err != nil { return nil, err } // Receive messages from stream. This may block indefinitely. res, err := it.ps.Recv() // The pullStream handles retries, so any error here is fatal. if err != nil { it.fail(err) return nil, err } msgs, err := convertMessages(res.ReceivedMessages) if err != nil { it.fail(err) return nil, err } // We received some messages. Remember them so we can keep them alive. Also, // arrange for a receipt mod-ack (which will occur at the next firing of // nackTicker). maxExt := time.Now().Add(it.po.maxExtension) deadline := trunc32(int64(it.po.ackDeadline.Seconds())) it.mu.Lock() now := time.Now() for _, m := range msgs { m.receiveTime = now m.doneFunc = it.done it.keepAliveDeadlines[m.ackID] = maxExt // The receipt mod-ack uses the subscription's configured ack deadline. Don't // change the mod-ack if one is already pending. This is possible if there // are retries. if _, ok := it.pendingModAcks[m.ackID]; !ok { it.pendingModAcks[m.ackID] = deadline } } it.mu.Unlock() return msgs, nil } // sender runs in a goroutine and handles all sends to the stream. func (it *streamingMessageIterator) sender() { defer it.wg.Done() defer it.kaTicker.Stop() defer it.ackTicker.Stop() defer it.nackTicker.Stop() defer it.ps.CloseSend() done := false for !done { send := false select { case <-it.ctx.Done(): // Context canceled or timed out: stop immediately, without // another RPC. return case <-it.failed: // Stream failed: nothing to do, so stop immediately. return case <-it.drained: // All outstanding messages have been marked done: // nothing left to do except send the final request. it.mu.Lock() send = (len(it.pendingReq.AckIds) > 0 || len(it.pendingModAcks) > 0) done = true case <-it.kaTicker.C: it.mu.Lock() it.handleKeepAlives() send = (len(it.pendingModAcks) > 0) case <-it.nackTicker.C: it.mu.Lock() send = (len(it.pendingModAcks) > 0) case <-it.ackTicker.C: it.mu.Lock() send = (len(it.pendingReq.AckIds) > 0) } // Lock is held here. if send { req := it.pendingReq it.pendingReq = &pb.StreamingPullRequest{} modAcks := it.pendingModAcks it.pendingModAcks = map[string]int32{} it.mu.Unlock() for id, s := range modAcks { req.ModifyDeadlineAckIds = append(req.ModifyDeadlineAckIds, id) req.ModifyDeadlineSeconds = append(req.ModifyDeadlineSeconds, s) } err := it.send(req) if err != nil { // The streamingPuller handles retries, so any error here // is fatal to the iterator. it.fail(err) return } } else { it.mu.Unlock() } } } func (it *streamingMessageIterator) send(req *pb.StreamingPullRequest) error { // Note: len(modAckIDs) == len(modSecs) var rest *pb.StreamingPullRequest for len(req.AckIds) > 0 || len(req.ModifyDeadlineAckIds) > 0 { req, rest = splitRequest(req, maxPayload) if err := it.ps.Send(req); err != nil { return err } req = rest } return nil } // handleKeepAlives modifies the pending request to include deadline extensions // for live messages. It also purges expired messages. // // Called with the lock held. func (it *streamingMessageIterator) handleKeepAlives() { now := time.Now() dl := trunc32(int64(it.po.ackDeadline.Seconds())) for id, expiry := range it.keepAliveDeadlines { if expiry.Before(now) { // This delete will not result in skipping any map items, as implied by // the spec at https://golang.org/ref/spec#For_statements, "For // statements with range clause", note 3, and stated explicitly at // https://groups.google.com/forum/#!msg/golang-nuts/UciASUb03Js/pzSq5iVFAQAJ. delete(it.keepAliveDeadlines, id) } else { // This will not overwrite a nack, because nacking removes the ID from keepAliveDeadlines. it.pendingModAcks[id] = dl } } it.checkDrained() } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/message.go ================================================ // Copyright 2016 Google Inc. 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. package pubsub import ( "time" "github.com/golang/protobuf/ptypes" pb "google.golang.org/genproto/googleapis/pubsub/v1" ) // Message represents a Pub/Sub message. type Message struct { // ID identifies this message. // This ID is assigned by the server and is populated for Messages obtained from a subscription. // This field is read-only. ID string // Data is the actual data in the message. Data []byte // Attributes represents the key-value pairs the current message // is labelled with. Attributes map[string]string // ackID is the identifier to acknowledge this message. ackID string // The time at which the message was published. // This is populated by the server for Messages obtained from a subscription. // This field is read-only. PublishTime time.Time // receiveTime is the time the message was received by the client. receiveTime time.Time // size is the approximate size of the message's data and attributes. size int calledDone bool // The done method of the iterator that created this Message. doneFunc func(string, bool, time.Time) } func toMessage(resp *pb.ReceivedMessage) (*Message, error) { if resp.Message == nil { return &Message{ackID: resp.AckId}, nil } pubTime, err := ptypes.Timestamp(resp.Message.PublishTime) if err != nil { return nil, err } return &Message{ ackID: resp.AckId, Data: resp.Message.Data, Attributes: resp.Message.Attributes, ID: resp.Message.MessageId, PublishTime: pubTime, }, nil } // Ack indicates successful processing of a Message passed to the Subscriber.Receive callback. // It should not be called on any other Message value. // If message acknowledgement fails, the Message will be redelivered. // Client code must call Ack or Nack when finished for each received Message. // Calls to Ack or Nack have no effect after the first call. func (m *Message) Ack() { m.done(true) } // Nack indicates that the client will not or cannot process a Message passed to the Subscriber.Receive callback. // It should not be called on any other Message value. // Nack will result in the Message being redelivered more quickly than if it were allowed to expire. // Client code must call Ack or Nack when finished for each received Message. // Calls to Ack or Nack have no effect after the first call. func (m *Message) Nack() { m.done(false) } func (m *Message) done(ack bool) { if m.calledDone { return } m.calledDone = true m.doneFunc(m.ackID, ack, m.receiveTime) } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/not_go18.go ================================================ // Copyright 2018 Google Inc. 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. // +build !go1.8 package pubsub import ( "golang.org/x/net/context" "google.golang.org/api/option" ) // OpenCensus only supports go 1.8 and higher. func openCensusOptions() []option.ClientOption { return nil } func withSubscriptionKey(ctx context.Context, _ string) context.Context { return ctx } type dummy struct{} var ( // Not supported below Go 1.8. PullCount dummy // Not supported below Go 1.8. AckCount dummy // Not supported below Go 1.8. NackCount dummy // Not supported below Go 1.8. ModAckCount dummy // Not supported below Go 1.8. StreamOpenCount dummy // Not supported below Go 1.8. StreamRetryCount dummy // Not supported below Go 1.8. StreamRequestCount dummy // Not supported below Go 1.8. StreamResponseCount dummy ) func recordStat(context.Context, dummy, int64) { } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/pubsub.go ================================================ // Copyright 2014 Google Inc. 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. package pubsub // import "cloud.google.com/go/pubsub" import ( "fmt" "os" "runtime" "time" "cloud.google.com/go/internal/version" vkit "cloud.google.com/go/pubsub/apiv1" "golang.org/x/net/context" "google.golang.org/api/option" "google.golang.org/grpc" "google.golang.org/grpc/keepalive" ) const ( // ScopePubSub grants permissions to view and manage Pub/Sub // topics and subscriptions. ScopePubSub = "https://www.googleapis.com/auth/pubsub" // ScopeCloudPlatform grants permissions to view and manage your data // across Google Cloud Platform services. ScopeCloudPlatform = "https://www.googleapis.com/auth/cloud-platform" ) const ( prodAddr = "https://pubsub.googleapis.com/" minAckDeadline = 10 * time.Second maxAckDeadline = 10 * time.Minute ) // Client is a Google Pub/Sub client scoped to a single project. // // Clients should be reused rather than being created as needed. // A Client may be shared by multiple goroutines. type Client struct { projectID string pubc *vkit.PublisherClient subc *vkit.SubscriberClient } // NewClient creates a new PubSub client. func NewClient(ctx context.Context, projectID string, opts ...option.ClientOption) (c *Client, err error) { var o []option.ClientOption // Environment variables for gcloud emulator: // https://cloud.google.com/sdk/gcloud/reference/beta/emulators/pubsub/ if addr := os.Getenv("PUBSUB_EMULATOR_HOST"); addr != "" { conn, err := grpc.Dial(addr, grpc.WithInsecure()) if err != nil { return nil, fmt.Errorf("grpc.Dial: %v", err) } o = []option.ClientOption{option.WithGRPCConn(conn)} } else { o = []option.ClientOption{ // Create multiple connections to increase throughput. option.WithGRPCConnectionPool(runtime.GOMAXPROCS(0)), option.WithGRPCDialOption(grpc.WithKeepaliveParams(keepalive.ClientParameters{ Time: 5 * time.Minute, })), } o = append(o, openCensusOptions()...) } o = append(o, opts...) pubc, err := vkit.NewPublisherClient(ctx, o...) if err != nil { return nil, fmt.Errorf("pubsub: %v", err) } subc, err := vkit.NewSubscriberClient(ctx, option.WithGRPCConn(pubc.Connection())) if err != nil { // Should never happen, since we are passing in the connection. // If it does, we cannot close, because the user may have passed in their // own connection originally. return nil, fmt.Errorf("pubsub: %v", err) } pubc.SetGoogleClientInfo("gccl", version.Repo) subc.SetGoogleClientInfo("gccl", version.Repo) return &Client{ projectID: projectID, pubc: pubc, subc: subc, }, nil } // Close releases any resources held by the client, // such as memory and goroutines. // // If the client is available for the lifetime of the program, then Close need not be // called at exit. func (c *Client) Close() error { // Return the first error, because the first call closes the connection. err := c.pubc.Close() _ = c.subc.Close() return err } func (c *Client) fullyQualifiedProjectName() string { return fmt.Sprintf("projects/%s", c.projectID) } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/pullstream.go ================================================ // Copyright 2018 Google Inc. 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. package pubsub import ( "io" "sync" "time" vkit "cloud.google.com/go/pubsub/apiv1" gax "github.com/googleapis/gax-go" "golang.org/x/net/context" pb "google.golang.org/genproto/googleapis/pubsub/v1" "google.golang.org/grpc" ) // A pullStream supports the methods of a StreamingPullClient, but re-opens // the stream on a retryable error. type pullStream struct { ctx context.Context open func() (pb.Subscriber_StreamingPullClient, error) mu sync.Mutex spc *pb.Subscriber_StreamingPullClient err error // permanent error } func newPullStream(ctx context.Context, subc *vkit.SubscriberClient, subName string, ackDeadlineSecs int32) *pullStream { ctx = withSubscriptionKey(ctx, subName) return &pullStream{ ctx: ctx, open: func() (pb.Subscriber_StreamingPullClient, error) { spc, err := subc.StreamingPull(ctx, gax.WithGRPCOptions(grpc.MaxCallRecvMsgSize(maxSendRecvBytes))) if err == nil { recordStat(ctx, StreamRequestCount, 1) err = spc.Send(&pb.StreamingPullRequest{ Subscription: subName, StreamAckDeadlineSeconds: ackDeadlineSecs, }) } if err != nil { return nil, err } return spc, nil }, } } // get returns either a valid *StreamingPullClient (SPC), or a permanent error. // If the argument is nil, this is the first call for an RPC, and the current // SPC will be returned (or a new one will be opened). Otherwise, this call is a // request to re-open the stream because of a retryable error, and the argument // is a pointer to the SPC that returned the error. func (s *pullStream) get(spc *pb.Subscriber_StreamingPullClient) (*pb.Subscriber_StreamingPullClient, error) { s.mu.Lock() defer s.mu.Unlock() // A stored error is permanent. if s.err != nil { return nil, s.err } // If the context is done, so are we. select { case <-s.ctx.Done(): s.err = s.ctx.Err() return nil, s.err default: } // TODO(jba): We can use the following instead of the above after we drop support for 1.8: // s.err = s.ctx.Err() // if s.err != nil { // return nil, s.err // } // If the current and argument SPCs differ, return the current one. This subsumes two cases: // 1. We have an SPC and the caller is getting the stream for the first time. // 2. The caller wants to retry, but they have an older SPC; we've already retried. if spc != s.spc { return s.spc, nil } // Either this is the very first call on this stream (s.spc == nil), or we have a valid // retry request. Either way, open a new stream. // The lock is held here for a long time, but it doesn't matter because no callers could get // anything done anyway. s.spc = new(pb.Subscriber_StreamingPullClient) recordStat(s.ctx, StreamOpenCount, 1) *s.spc, s.err = s.open() // Setting s.err means any error from open is permanent. Reconsider. return s.spc, s.err } func (s *pullStream) call(f func(pb.Subscriber_StreamingPullClient) error) error { var ( spc *pb.Subscriber_StreamingPullClient err error bo gax.Backoff ) for i := 0; ; i++ { spc, err = s.get(spc) if err != nil { // Preserve the existing behavior of not retrying on open. Is that a bug? // (If we do decide to retry, don't retry after we're closed.) return err } start := time.Now() err = f(*spc) if err != nil { if isRetryable(err) { recordStat(s.ctx, StreamRetryCount, 1) if time.Since(start) < 30*time.Second { // don't sleep if we've been blocked for a while if err := gax.Sleep(s.ctx, bo.Pause()); err != nil { return err } } continue } s.mu.Lock() s.err = err s.mu.Unlock() } return err } } func (s *pullStream) Send(req *pb.StreamingPullRequest) error { return s.call(func(spc pb.Subscriber_StreamingPullClient) error { recordStat(s.ctx, AckCount, int64(len(req.AckIds))) zeroes := 0 for _, mds := range req.ModifyDeadlineSeconds { if mds == 0 { zeroes++ } } recordStat(s.ctx, NackCount, int64(zeroes)) recordStat(s.ctx, ModAckCount, int64(len(req.ModifyDeadlineSeconds)-zeroes)) recordStat(s.ctx, StreamRequestCount, 1) return spc.Send(req) }) } func (s *pullStream) Recv() (*pb.StreamingPullResponse, error) { var res *pb.StreamingPullResponse err := s.call(func(spc pb.Subscriber_StreamingPullClient) error { var err error recordStat(s.ctx, StreamResponseCount, 1) res, err = spc.Recv() if err == nil { recordStat(s.ctx, PullCount, int64(len(res.ReceivedMessages))) } return err }) return res, err } func (s *pullStream) CloseSend() error { err := s.call(func(spc pb.Subscriber_StreamingPullClient) error { return spc.CloseSend() }) s.mu.Lock() s.err = io.EOF // should not be retried s.mu.Unlock() return err } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/service.go ================================================ // Copyright 2016 Google Inc. 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. package pubsub import ( "fmt" "math" "strings" pb "google.golang.org/genproto/googleapis/pubsub/v1" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" ) // maxPayload is the maximum number of bytes to devote to actual ids in // acknowledgement or modifyAckDeadline requests. A serialized // AcknowledgeRequest proto has a small constant overhead, plus the size of the // subscription name, plus 3 bytes per ID (a tag byte and two size bytes). A // ModifyAckDeadlineRequest has an additional few bytes for the deadline. We // don't know the subscription name here, so we just assume the size exclusive // of ids is 100 bytes. // // With gRPC there is no way for the client to know the server's max message size (it is // configurable on the server). We know from experience that it // it 512K. const ( maxPayload = 512 * 1024 reqFixedOverhead = 100 overheadPerID = 3 maxSendRecvBytes = 20 * 1024 * 1024 // 20M ) func convertMessages(rms []*pb.ReceivedMessage) ([]*Message, error) { msgs := make([]*Message, 0, len(rms)) for i, m := range rms { msg, err := toMessage(m) if err != nil { return nil, fmt.Errorf("pubsub: cannot decode the retrieved message at index: %d, message: %+v", i, m) } msgs = append(msgs, msg) } return msgs, nil } func trunc32(i int64) int32 { if i > math.MaxInt32 { i = math.MaxInt32 } return int32(i) } // Logic from https://github.com/GoogleCloudPlatform/google-cloud-java/blob/master/google-cloud-pubsub/src/main/java/com/google/cloud/pubsub/v1/StatusUtil.java. func isRetryable(err error) bool { s, ok := status.FromError(err) if !ok { // includes io.EOF, normal stream close, which causes us to reopen return true } switch s.Code() { case codes.DeadlineExceeded, codes.Internal, codes.Canceled, codes.ResourceExhausted: return true case codes.Unavailable: return !strings.Contains(s.Message(), "Server shutdownNow invoked") default: return false } } // Split req into a prefix that is smaller than maxSize, and a remainder. func splitRequest(req *pb.StreamingPullRequest, maxSize int) (prefix, remainder *pb.StreamingPullRequest) { const int32Bytes = 4 // Copy all fields before splitting the variable-sized ones. remainder = &pb.StreamingPullRequest{} *remainder = *req // Split message so it isn't too big. size := reqFixedOverhead i := 0 for size < maxSize && (i < len(req.AckIds) || i < len(req.ModifyDeadlineAckIds)) { if i < len(req.AckIds) { size += overheadPerID + len(req.AckIds[i]) } if i < len(req.ModifyDeadlineAckIds) { size += overheadPerID + len(req.ModifyDeadlineAckIds[i]) + int32Bytes } i++ } min := func(a, b int) int { if a < b { return a } return b } j := i if size > maxSize { j-- } k := min(j, len(req.AckIds)) remainder.AckIds = req.AckIds[k:] req.AckIds = req.AckIds[:k] k = min(j, len(req.ModifyDeadlineAckIds)) remainder.ModifyDeadlineAckIds = req.ModifyDeadlineAckIds[k:] remainder.ModifyDeadlineSeconds = req.ModifyDeadlineSeconds[k:] req.ModifyDeadlineAckIds = req.ModifyDeadlineAckIds[:k] req.ModifyDeadlineSeconds = req.ModifyDeadlineSeconds[:k] return req, remainder } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/snapshot.go ================================================ // Copyright 2017 Google Inc. 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. package pubsub import ( "fmt" "strings" "time" "github.com/golang/protobuf/ptypes" "golang.org/x/net/context" pb "google.golang.org/genproto/googleapis/pubsub/v1" ) // Snapshot is a reference to a PubSub snapshot. type Snapshot struct { c *Client // The fully qualified identifier for the snapshot, in the format "projects//snapshots/" name string } // ID returns the unique identifier of the snapshot within its project. func (s *Snapshot) ID() string { slash := strings.LastIndex(s.name, "/") if slash == -1 { // name is not a fully-qualified name. panic("bad snapshot name") } return s.name[slash+1:] } // SnapshotConfig contains the details of a Snapshot. type SnapshotConfig struct { *Snapshot Topic *Topic Expiration time.Time } // Snapshot creates a reference to a snapshot. func (c *Client) Snapshot(id string) *Snapshot { return &Snapshot{ c: c, name: fmt.Sprintf("projects/%s/snapshots/%s", c.projectID, id), } } // Snapshots returns an iterator which returns snapshots for this project. func (c *Client) Snapshots(ctx context.Context) *SnapshotConfigIterator { it := c.subc.ListSnapshots(ctx, &pb.ListSnapshotsRequest{ Project: c.fullyQualifiedProjectName(), }) next := func() (*SnapshotConfig, error) { snap, err := it.Next() if err != nil { return nil, err } return toSnapshotConfig(snap, c) } return &SnapshotConfigIterator{next: next} } // SnapshotConfigIterator is an iterator that returns a series of snapshots. type SnapshotConfigIterator struct { next func() (*SnapshotConfig, error) } // Next returns the next SnapshotConfig. Its second return value is iterator.Done if there are no more results. // Once Next returns iterator.Done, all subsequent calls will return iterator.Done. func (snaps *SnapshotConfigIterator) Next() (*SnapshotConfig, error) { return snaps.next() } // Delete deletes a snapshot. func (snap *Snapshot) Delete(ctx context.Context) error { return snap.c.subc.DeleteSnapshot(ctx, &pb.DeleteSnapshotRequest{Snapshot: snap.name}) } // SeekToTime seeks the subscription to a point in time. // // Messages retained in the subscription that were published before this // time are marked as acknowledged, and messages retained in the // subscription that were published after this time are marked as // unacknowledged. Note that this operation affects only those messages // retained in the subscription (configured by SnapshotConfig). For example, // if `time` corresponds to a point before the message retention // window (or to a point before the system's notion of the subscription // creation time), only retained messages will be marked as unacknowledged, // and already-expunged messages will not be restored. func (s *Subscription) SeekToTime(ctx context.Context, t time.Time) error { ts, err := ptypes.TimestampProto(t) if err != nil { return err } _, err = s.c.subc.Seek(ctx, &pb.SeekRequest{ Subscription: s.name, Target: &pb.SeekRequest_Time{ts}, }) return err } // CreateSnapshot creates a new snapshot from this subscription. // The snapshot will be for the topic this subscription is subscribed to. // If the name is empty string, a unique name is assigned. // // The created snapshot is guaranteed to retain: // (a) The existing backlog on the subscription. More precisely, this is // defined as the messages in the subscription's backlog that are // unacknowledged when Snapshot returns without error. // (b) Any messages published to the subscription's topic following // Snapshot returning without error. func (s *Subscription) CreateSnapshot(ctx context.Context, name string) (*SnapshotConfig, error) { if name != "" { name = fmt.Sprintf("projects/%s/snapshots/%s", strings.Split(s.name, "/")[1], name) } snap, err := s.c.subc.CreateSnapshot(ctx, &pb.CreateSnapshotRequest{ Name: name, Subscription: s.name, }) if err != nil { return nil, err } return toSnapshotConfig(snap, s.c) } // SeekToSnapshot seeks the subscription to a snapshot. // // The snapshot need not be created from this subscription, // but it must be for the topic this subscription is subscribed to. func (s *Subscription) SeekToSnapshot(ctx context.Context, snap *Snapshot) error { _, err := s.c.subc.Seek(ctx, &pb.SeekRequest{ Subscription: s.name, Target: &pb.SeekRequest_Snapshot{snap.name}, }) return err } func toSnapshotConfig(snap *pb.Snapshot, c *Client) (*SnapshotConfig, error) { exp, err := ptypes.Timestamp(snap.ExpireTime) if err != nil { return nil, err } return &SnapshotConfig{ Snapshot: &Snapshot{c: c, name: snap.Name}, Topic: newTopic(c, snap.Topic), Expiration: exp, }, nil } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/subscription.go ================================================ // Copyright 2016 Google Inc. 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. package pubsub import ( "errors" "fmt" "io" "strings" "sync" "time" "cloud.google.com/go/iam" "cloud.google.com/go/internal/optional" "github.com/golang/protobuf/ptypes" durpb "github.com/golang/protobuf/ptypes/duration" "golang.org/x/net/context" "golang.org/x/sync/errgroup" pb "google.golang.org/genproto/googleapis/pubsub/v1" fmpb "google.golang.org/genproto/protobuf/field_mask" "google.golang.org/grpc" "google.golang.org/grpc/codes" ) // Subscription is a reference to a PubSub subscription. type Subscription struct { c *Client // The fully qualified identifier for the subscription, in the format "projects//subscriptions/" name string // Settings for pulling messages. Configure these before calling Receive. ReceiveSettings ReceiveSettings mu sync.Mutex receiveActive bool } // Subscription creates a reference to a subscription. func (c *Client) Subscription(id string) *Subscription { return c.SubscriptionInProject(id, c.projectID) } // SubscriptionInProject creates a reference to a subscription in a given project. func (c *Client) SubscriptionInProject(id, projectID string) *Subscription { return &Subscription{ c: c, name: fmt.Sprintf("projects/%s/subscriptions/%s", projectID, id), } } // String returns the globally unique printable name of the subscription. func (s *Subscription) String() string { return s.name } // ID returns the unique identifier of the subscription within its project. func (s *Subscription) ID() string { slash := strings.LastIndex(s.name, "/") if slash == -1 { // name is not a fully-qualified name. panic("bad subscription name") } return s.name[slash+1:] } // Subscriptions returns an iterator which returns all of the subscriptions for the client's project. func (c *Client) Subscriptions(ctx context.Context) *SubscriptionIterator { it := c.subc.ListSubscriptions(ctx, &pb.ListSubscriptionsRequest{ Project: c.fullyQualifiedProjectName(), }) return &SubscriptionIterator{ c: c, next: func() (string, error) { sub, err := it.Next() if err != nil { return "", err } return sub.Name, nil }, } } // SubscriptionIterator is an iterator that returns a series of subscriptions. type SubscriptionIterator struct { c *Client next func() (string, error) } // Next returns the next subscription. If there are no more subscriptions, iterator.Done will be returned. func (subs *SubscriptionIterator) Next() (*Subscription, error) { subName, err := subs.next() if err != nil { return nil, err } return &Subscription{c: subs.c, name: subName}, nil } // PushConfig contains configuration for subscriptions that operate in push mode. type PushConfig struct { // A URL locating the endpoint to which messages should be pushed. Endpoint string // Endpoint configuration attributes. See https://cloud.google.com/pubsub/docs/reference/rest/v1/projects.subscriptions#pushconfig for more details. Attributes map[string]string } func (pc *PushConfig) toProto() *pb.PushConfig { return &pb.PushConfig{ Attributes: pc.Attributes, PushEndpoint: pc.Endpoint, } } // Subscription config contains the configuration of a subscription. type SubscriptionConfig struct { Topic *Topic PushConfig PushConfig // The default maximum time after a subscriber receives a message before // the subscriber should acknowledge the message. Note: messages which are // obtained via Subscription.Receive need not be acknowledged within this // deadline, as the deadline will be automatically extended. AckDeadline time.Duration // Whether to retain acknowledged messages. If true, acknowledged messages // will not be expunged until they fall out of the RetentionDuration window. RetainAckedMessages bool // How long to retain messages in backlog, from the time of publish. If // RetainAckedMessages is true, this duration affects the retention of // acknowledged messages, otherwise only unacknowledged messages are retained. // Defaults to 7 days. Cannot be longer than 7 days or shorter than 10 minutes. RetentionDuration time.Duration } func (cfg *SubscriptionConfig) toProto(name string) *pb.Subscription { var pbPushConfig *pb.PushConfig if cfg.PushConfig.Endpoint != "" || len(cfg.PushConfig.Attributes) != 0 { pbPushConfig = &pb.PushConfig{ Attributes: cfg.PushConfig.Attributes, PushEndpoint: cfg.PushConfig.Endpoint, } } var retentionDuration *durpb.Duration if cfg.RetentionDuration != 0 { retentionDuration = ptypes.DurationProto(cfg.RetentionDuration) } return &pb.Subscription{ Name: name, Topic: cfg.Topic.name, PushConfig: pbPushConfig, AckDeadlineSeconds: trunc32(int64(cfg.AckDeadline.Seconds())), RetainAckedMessages: cfg.RetainAckedMessages, MessageRetentionDuration: retentionDuration, } } func protoToSubscriptionConfig(pbSub *pb.Subscription, c *Client) (SubscriptionConfig, error) { rd := time.Hour * 24 * 7 var err error if pbSub.MessageRetentionDuration != nil { rd, err = ptypes.Duration(pbSub.MessageRetentionDuration) if err != nil { return SubscriptionConfig{}, err } } return SubscriptionConfig{ Topic: newTopic(c, pbSub.Topic), AckDeadline: time.Second * time.Duration(pbSub.AckDeadlineSeconds), PushConfig: PushConfig{ Endpoint: pbSub.PushConfig.PushEndpoint, Attributes: pbSub.PushConfig.Attributes, }, RetainAckedMessages: pbSub.RetainAckedMessages, RetentionDuration: rd, }, nil } // ReceiveSettings configure the Receive method. // A zero ReceiveSettings will result in values equivalent to DefaultReceiveSettings. type ReceiveSettings struct { // MaxExtension is the maximum period for which the Subscription should // automatically extend the ack deadline for each message. // // The Subscription will automatically extend the ack deadline of all // fetched Messages for the duration specified. Automatic deadline // extension may be disabled by specifying a duration less than 0. // // Connections may be terminated if they last longer than 30m, which // effectively makes that the ceiling for this value. For longer message // processing, see the example at https://godoc.org/cloud.google.com/go/pubsub/apiv1#example_SubscriberClient_Pull_lengthyClientProcessing MaxExtension time.Duration // MaxOutstandingMessages is the maximum number of unprocessed messages // (unacknowledged but not yet expired). If MaxOutstandingMessages is 0, it // will be treated as if it were DefaultReceiveSettings.MaxOutstandingMessages. // If the value is negative, then there will be no limit on the number of // unprocessed messages. MaxOutstandingMessages int // MaxOutstandingBytes is the maximum size of unprocessed messages // (unacknowledged but not yet expired). If MaxOutstandingBytes is 0, it will // be treated as if it were DefaultReceiveSettings.MaxOutstandingBytes. If // the value is negative, then there will be no limit on the number of bytes // for unprocessed messages. MaxOutstandingBytes int // NumGoroutines is the number of goroutines Receive will spawn to pull // messages concurrently. If NumGoroutines is less than 1, it will be treated // as if it were DefaultReceiveSettings.NumGoroutines. // // NumGoroutines does not limit the number of messages that can be processed // concurrently. Even with one goroutine, many messages might be processed at // once, because that goroutine may continually receive messages and invoke the // function passed to Receive on them. To limit the number of messages being // processed concurrently, set MaxOutstandingMessages. NumGoroutines int } // DefaultReceiveSettings holds the default values for ReceiveSettings. var DefaultReceiveSettings = ReceiveSettings{ MaxExtension: 10 * time.Minute, MaxOutstandingMessages: 1000, MaxOutstandingBytes: 1e9, // 1G NumGoroutines: 1, } // Delete deletes the subscription. func (s *Subscription) Delete(ctx context.Context) error { return s.c.subc.DeleteSubscription(ctx, &pb.DeleteSubscriptionRequest{Subscription: s.name}) } // Exists reports whether the subscription exists on the server. func (s *Subscription) Exists(ctx context.Context) (bool, error) { _, err := s.c.subc.GetSubscription(ctx, &pb.GetSubscriptionRequest{Subscription: s.name}) if err == nil { return true, nil } if grpc.Code(err) == codes.NotFound { return false, nil } return false, err } // Config fetches the current configuration for the subscription. func (s *Subscription) Config(ctx context.Context) (SubscriptionConfig, error) { pbSub, err := s.c.subc.GetSubscription(ctx, &pb.GetSubscriptionRequest{Subscription: s.name}) if err != nil { return SubscriptionConfig{}, err } cfg, err := protoToSubscriptionConfig(pbSub, s.c) if err != nil { return SubscriptionConfig{}, err } return cfg, nil } // SubscriptionConfigToUpdate describes how to update a subscription. type SubscriptionConfigToUpdate struct { // If non-nil, the push config is changed. PushConfig *PushConfig // If non-zero, the ack deadline is changed. AckDeadline time.Duration // If set, RetainAckedMessages is changed. RetainAckedMessages optional.Bool // If non-zero, RetentionDuration is changed. RetentionDuration time.Duration } // Update changes an existing subscription according to the fields set in cfg. // It returns the new SubscriptionConfig. // // Update returns an error if no fields were modified. func (s *Subscription) Update(ctx context.Context, cfg SubscriptionConfigToUpdate) (SubscriptionConfig, error) { req := s.updateRequest(&cfg) if len(req.UpdateMask.Paths) == 0 { return SubscriptionConfig{}, errors.New("pubsub: UpdateSubscription call with nothing to update") } rpsub, err := s.c.subc.UpdateSubscription(ctx, req) if err != nil { return SubscriptionConfig{}, err } return protoToSubscriptionConfig(rpsub, s.c) } func (s *Subscription) updateRequest(cfg *SubscriptionConfigToUpdate) *pb.UpdateSubscriptionRequest { psub := &pb.Subscription{Name: s.name} var paths []string if cfg.PushConfig != nil { psub.PushConfig = cfg.PushConfig.toProto() paths = append(paths, "push_config") } if cfg.AckDeadline != 0 { psub.AckDeadlineSeconds = trunc32(int64(cfg.AckDeadline.Seconds())) paths = append(paths, "ack_deadline_seconds") } if cfg.RetainAckedMessages != nil { psub.RetainAckedMessages = optional.ToBool(cfg.RetainAckedMessages) paths = append(paths, "retain_acked_messages") } if cfg.RetentionDuration != 0 { psub.MessageRetentionDuration = ptypes.DurationProto(cfg.RetentionDuration) paths = append(paths, "message_retention_duration") } return &pb.UpdateSubscriptionRequest{ Subscription: psub, UpdateMask: &fmpb.FieldMask{Paths: paths}, } } func (s *Subscription) IAM() *iam.Handle { return iam.InternalNewHandle(s.c.subc.Connection(), s.name) } // CreateSubscription creates a new subscription on a topic. // // id is the name of the subscription to create. It must start with a letter, // and contain only letters ([A-Za-z]), numbers ([0-9]), dashes (-), // underscores (_), periods (.), tildes (~), plus (+) or percent signs (%). It // must be between 3 and 255 characters in length, and must not start with // "goog". // // cfg.Topic is the topic from which the subscription should receive messages. It // need not belong to the same project as the subscription. This field is required. // // cfg.AckDeadline is the maximum time after a subscriber receives a message before // the subscriber should acknowledge the message. It must be between 10 and 600 // seconds (inclusive), and is rounded down to the nearest second. If the // provided ackDeadline is 0, then the default value of 10 seconds is used. // Note: messages which are obtained via Subscription.Receive need not be // acknowledged within this deadline, as the deadline will be automatically // extended. // // cfg.PushConfig may be set to configure this subscription for push delivery. // // If the subscription already exists an error will be returned. func (c *Client) CreateSubscription(ctx context.Context, id string, cfg SubscriptionConfig) (*Subscription, error) { if cfg.Topic == nil { return nil, errors.New("pubsub: require non-nil Topic") } if cfg.AckDeadline == 0 { cfg.AckDeadline = 10 * time.Second } if d := cfg.AckDeadline; d < 10*time.Second || d > 600*time.Second { return nil, fmt.Errorf("ack deadline must be between 10 and 600 seconds; got: %v", d) } sub := c.Subscription(id) _, err := c.subc.CreateSubscription(ctx, cfg.toProto(sub.name)) if err != nil { return nil, err } return sub, nil } var errReceiveInProgress = errors.New("pubsub: Receive already in progress for this subscription") // Receive calls f with the outstanding messages from the subscription. // It blocks until ctx is done, or the service returns a non-retryable error. // // The standard way to terminate a Receive is to cancel its context: // // cctx, cancel := context.WithCancel(ctx) // err := sub.Receive(cctx, callback) // // Call cancel from callback, or another goroutine. // // If the service returns a non-retryable error, Receive returns that error after // all of the outstanding calls to f have returned. If ctx is done, Receive // returns nil after all of the outstanding calls to f have returned and // all messages have been acknowledged or have expired. // // Receive calls f concurrently from multiple goroutines. It is encouraged to // process messages synchronously in f, even if that processing is relatively // time-consuming; Receive will spawn new goroutines for incoming messages, // limited by MaxOutstandingMessages and MaxOutstandingBytes in ReceiveSettings. // // The context passed to f will be canceled when ctx is Done or there is a // fatal service error. // // Receive will automatically extend the ack deadline of all fetched Messages for the // period specified by s.ReceiveSettings.MaxExtension. // // Each Subscription may have only one invocation of Receive active at a time. func (s *Subscription) Receive(ctx context.Context, f func(context.Context, *Message)) error { s.mu.Lock() if s.receiveActive { s.mu.Unlock() return errReceiveInProgress } s.receiveActive = true s.mu.Unlock() defer func() { s.mu.Lock(); s.receiveActive = false; s.mu.Unlock() }() config, err := s.Config(ctx) if err != nil { if grpc.Code(err) == codes.Canceled { return nil } return err } maxCount := s.ReceiveSettings.MaxOutstandingMessages if maxCount == 0 { maxCount = DefaultReceiveSettings.MaxOutstandingMessages } maxBytes := s.ReceiveSettings.MaxOutstandingBytes if maxBytes == 0 { maxBytes = DefaultReceiveSettings.MaxOutstandingBytes } maxExt := s.ReceiveSettings.MaxExtension if maxExt == 0 { maxExt = DefaultReceiveSettings.MaxExtension } else if maxExt < 0 { // If MaxExtension is negative, disable automatic extension. maxExt = 0 } numGoroutines := s.ReceiveSettings.NumGoroutines if numGoroutines < 1 { numGoroutines = DefaultReceiveSettings.NumGoroutines } // TODO(jba): add tests that verify that ReceiveSettings are correctly processed. po := &pullOptions{ maxExtension: maxExt, maxPrefetch: trunc32(int64(maxCount)), ackDeadline: config.AckDeadline, } fc := newFlowController(maxCount, maxBytes) // Wait for all goroutines started by Receive to return, so instead of an // obscure goroutine leak we have an obvious blocked call to Receive. group, gctx := errgroup.WithContext(ctx) for i := 0; i < numGoroutines; i++ { group.Go(func() error { return s.receive(gctx, po, fc, f) }) } return group.Wait() } func (s *Subscription) receive(ctx context.Context, po *pullOptions, fc *flowController, f func(context.Context, *Message)) error { // Cancel a sub-context when we return, to kick the context-aware callbacks // and the goroutine below. ctx2, cancel := context.WithCancel(ctx) // Call stop when Receive's context is done. // Stop will block until all outstanding messages have been acknowledged // or there was a fatal service error. // The iterator does not use the context passed to Receive. If it did, canceling // that context would immediately stop the iterator without waiting for unacked // messages. iter := newMessageIterator(context.Background(), s.c.subc, s.name, po) // We cannot use errgroup from Receive here. Receive might already be calling group.Wait, // and group.Wait cannot be called concurrently with group.Go. We give each receive() its // own WaitGroup instead. // Since wg.Add is only called from the main goroutine, wg.Wait is guaranteed // to be called after all Adds. var wg sync.WaitGroup wg.Add(1) go func() { <-ctx2.Done() iter.stop() wg.Done() }() defer wg.Wait() defer cancel() for { msgs, err := iter.receive() if err == io.EOF { return nil } if err != nil { return err } for i, msg := range msgs { msg := msg // TODO(jba): call acquire closer to when the message is allocated. if err := fc.acquire(ctx, len(msg.Data)); err != nil { // TODO(jba): test that these "orphaned" messages are nacked immediately when ctx is done. for _, m := range msgs[i:] { m.Nack() } return nil } old := msg.doneFunc msgLen := len(msg.Data) msg.doneFunc = func(ackID string, ack bool, receiveTime time.Time) { defer fc.release(msgLen) old(ackID, ack, receiveTime) } wg.Add(1) go func() { defer wg.Done() f(ctx2, msg) }() } } } // TODO(jba): remove when we delete messageIterator. type pullOptions struct { maxExtension time.Duration maxPrefetch int32 // ackDeadline is the default ack deadline for the subscription. Not // configurable. ackDeadline time.Duration } ================================================ FILE: rocketmq-knative/source/vendor/cloud.google.com/go/pubsub/topic.go ================================================ // Copyright 2016 Google Inc. 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. package pubsub import ( "errors" "fmt" "runtime" "strings" "sync" "time" "cloud.google.com/go/iam" "github.com/golang/protobuf/proto" gax "github.com/googleapis/gax-go" "golang.org/x/net/context" "google.golang.org/api/support/bundler" pb "google.golang.org/genproto/googleapis/pubsub/v1" "google.golang.org/grpc" "google.golang.org/grpc/codes" ) const ( // The maximum number of messages that can be in a single publish request, as // determined by the PubSub service. MaxPublishRequestCount = 1000 // The maximum size of a single publish request in bytes, as determined by the PubSub service. MaxPublishRequestBytes = 1e7 maxInt = int(^uint(0) >> 1) ) // ErrOversizedMessage indicates that a message's size exceeds MaxPublishRequestBytes. var ErrOversizedMessage = bundler.ErrOversizedItem // Topic is a reference to a PubSub topic. // // The methods of Topic are safe for use by multiple goroutines. type Topic struct { c *Client // The fully qualified identifier for the topic, in the format "projects//topics/" name string // Settings for publishing messages. All changes must be made before the // first call to Publish. The default is DefaultPublishSettings. PublishSettings PublishSettings mu sync.RWMutex stopped bool bundler *bundler.Bundler wg sync.WaitGroup // Channel for message bundles to be published. Close to indicate that Stop was called. bundlec chan []*bundledMessage } // PublishSettings control the bundling of published messages. type PublishSettings struct { // Publish a non-empty batch after this delay has passed. DelayThreshold time.Duration // Publish a batch when it has this many messages. The maximum is // MaxPublishRequestCount. CountThreshold int // Publish a batch when its size in bytes reaches this value. ByteThreshold int // The number of goroutines that invoke the Publish RPC concurrently. // Defaults to a multiple of GOMAXPROCS. NumGoroutines int // The maximum time that the client will attempt to publish a bundle of messages. Timeout time.Duration } // DefaultPublishSettings holds the default values for topics' PublishSettings. var DefaultPublishSettings = PublishSettings{ DelayThreshold: 1 * time.Millisecond, CountThreshold: 100, ByteThreshold: 1e6, Timeout: 60 * time.Second, } // CreateTopic creates a new topic. // The specified topic ID must start with a letter, and contain only letters // ([A-Za-z]), numbers ([0-9]), dashes (-), underscores (_), periods (.), // tildes (~), plus (+) or percent signs (%). It must be between 3 and 255 // characters in length, and must not start with "goog". // If the topic already exists an error will be returned. func (c *Client) CreateTopic(ctx context.Context, id string) (*Topic, error) { t := c.Topic(id) _, err := c.pubc.CreateTopic(ctx, &pb.Topic{Name: t.name}) if err != nil { return nil, err } return t, nil } // Topic creates a reference to a topic in the client's project. // // If a Topic's Publish method is called, it has background goroutines // associated with it. Clean them up by calling Topic.Stop. // // Avoid creating many Topic instances if you use them to publish. func (c *Client) Topic(id string) *Topic { return c.TopicInProject(id, c.projectID) } // TopicInProject creates a reference to a topic in the given project. // // If a Topic's Publish method is called, it has background goroutines // associated with it. Clean them up by calling Topic.Stop. // // Avoid creating many Topic instances if you use them to publish. func (c *Client) TopicInProject(id, projectID string) *Topic { return newTopic(c, fmt.Sprintf("projects/%s/topics/%s", projectID, id)) } func newTopic(c *Client, name string) *Topic { // bundlec is unbuffered. A buffer would occupy memory not // accounted for by the bundler, so BufferedByteLimit would be a lie: // the actual memory consumed would be higher. return &Topic{ c: c, name: name, PublishSettings: DefaultPublishSettings, bundlec: make(chan []*bundledMessage), } } // Topics returns an iterator which returns all of the topics for the client's project. func (c *Client) Topics(ctx context.Context) *TopicIterator { it := c.pubc.ListTopics(ctx, &pb.ListTopicsRequest{Project: c.fullyQualifiedProjectName()}) return &TopicIterator{ c: c, next: func() (string, error) { topic, err := it.Next() if err != nil { return "", err } return topic.Name, nil }, } } // TopicIterator is an iterator that returns a series of topics. type TopicIterator struct { c *Client next func() (string, error) } // Next returns the next topic. If there are no more topics, iterator.Done will be returned. func (tps *TopicIterator) Next() (*Topic, error) { topicName, err := tps.next() if err != nil { return nil, err } return newTopic(tps.c, topicName), nil } // ID returns the unique idenfier of the topic within its project. func (t *Topic) ID() string { slash := strings.LastIndex(t.name, "/") if slash == -1 { // name is not a fully-qualified name. panic("bad topic name") } return t.name[slash+1:] } // String returns the printable globally unique name for the topic. func (t *Topic) String() string { return t.name } // Delete deletes the topic. func (t *Topic) Delete(ctx context.Context) error { return t.c.pubc.DeleteTopic(ctx, &pb.DeleteTopicRequest{Topic: t.name}) } // Exists reports whether the topic exists on the server. func (t *Topic) Exists(ctx context.Context) (bool, error) { if t.name == "_deleted-topic_" { return false, nil } _, err := t.c.pubc.GetTopic(ctx, &pb.GetTopicRequest{Topic: t.name}) if err == nil { return true, nil } if grpc.Code(err) == codes.NotFound { return false, nil } return false, err } func (t *Topic) IAM() *iam.Handle { return iam.InternalNewHandle(t.c.pubc.Connection(), t.name) } // Subscriptions returns an iterator which returns the subscriptions for this topic. // // Some of the returned subscriptions may belong to a project other than t. func (t *Topic) Subscriptions(ctx context.Context) *SubscriptionIterator { it := t.c.pubc.ListTopicSubscriptions(ctx, &pb.ListTopicSubscriptionsRequest{ Topic: t.name, }) return &SubscriptionIterator{ c: t.c, next: it.Next, } } var errTopicStopped = errors.New("pubsub: Stop has been called for this topic") // Publish publishes msg to the topic asynchronously. Messages are batched and // sent according to the topic's PublishSettings. Publish never blocks. // // Publish returns a non-nil PublishResult which will be ready when the // message has been sent (or has failed to be sent) to the server. // // Publish creates goroutines for batching and sending messages. These goroutines // need to be stopped by calling t.Stop(). Once stopped, future calls to Publish // will immediately return a PublishResult with an error. func (t *Topic) Publish(ctx context.Context, msg *Message) *PublishResult { // TODO(jba): if this turns out to take significant time, try to approximate it. // Or, convert the messages to protos in Publish, instead of in the service. msg.size = proto.Size(&pb.PubsubMessage{ Data: msg.Data, Attributes: msg.Attributes, }) r := &PublishResult{ready: make(chan struct{})} t.initBundler() t.mu.RLock() defer t.mu.RUnlock() // TODO(aboulhosn) [from bcmills] consider changing the semantics of bundler to perform this logic so we don't have to do it here if t.stopped { r.set("", errTopicStopped) return r } // TODO(jba) [from bcmills] consider using a shared channel per bundle // (requires Bundler API changes; would reduce allocations) // The call to Add should never return an error because the bundler's // BufferedByteLimit is set to maxInt; we do not perform any flow // control in the client. err := t.bundler.Add(&bundledMessage{msg, r}, msg.size) if err != nil { r.set("", err) } return r } // Send all remaining published messages and stop goroutines created for handling // publishing. Returns once all outstanding messages have been sent or have // failed to be sent. func (t *Topic) Stop() { t.mu.Lock() noop := t.stopped || t.bundler == nil t.stopped = true t.mu.Unlock() if noop { return } t.bundler.Flush() // At this point, all pending bundles have been published and the bundler's // goroutines have exited, so it is OK for this goroutine to close bundlec. close(t.bundlec) t.wg.Wait() } // A PublishResult holds the result from a call to Publish. type PublishResult struct { ready chan struct{} serverID string err error } // Ready returns a channel that is closed when the result is ready. // When the Ready channel is closed, Get is guaranteed not to block. func (r *PublishResult) Ready() <-chan struct{} { return r.ready } // Get returns the server-generated message ID and/or error result of a Publish call. // Get blocks until the Publish call completes or the context is done. func (r *PublishResult) Get(ctx context.Context) (serverID string, err error) { // If the result is already ready, return it even if the context is done. select { case <-r.Ready(): return r.serverID, r.err default: } select { case <-ctx.Done(): return "", ctx.Err() case <-r.Ready(): return r.serverID, r.err } } func (r *PublishResult) set(sid string, err error) { r.serverID = sid r.err = err close(r.ready) } type bundledMessage struct { msg *Message res *PublishResult } func (t *Topic) initBundler() { t.mu.RLock() noop := t.stopped || t.bundler != nil t.mu.RUnlock() if noop { return } t.mu.Lock() defer t.mu.Unlock() // Must re-check, since we released the lock. if t.stopped || t.bundler != nil { return } // TODO(jba): use a context detached from the one passed to NewClient. ctx := context.TODO() // Unless overridden, run several goroutines per CPU to call the Publish RPC. n := t.PublishSettings.NumGoroutines if n <= 0 { n = 25 * runtime.GOMAXPROCS(0) } timeout := t.PublishSettings.Timeout t.wg.Add(n) for i := 0; i < n; i++ { go func() { defer t.wg.Done() for b := range t.bundlec { bctx := ctx cancel := func() {} if timeout != 0 { bctx, cancel = context.WithTimeout(ctx, timeout) } t.publishMessageBundle(bctx, b) cancel() } }() } t.bundler = bundler.NewBundler(&bundledMessage{}, func(items interface{}) { t.bundlec <- items.([]*bundledMessage) }) t.bundler.DelayThreshold = t.PublishSettings.DelayThreshold t.bundler.BundleCountThreshold = t.PublishSettings.CountThreshold if t.bundler.BundleCountThreshold > MaxPublishRequestCount { t.bundler.BundleCountThreshold = MaxPublishRequestCount } t.bundler.BundleByteThreshold = t.PublishSettings.ByteThreshold t.bundler.BufferedByteLimit = maxInt t.bundler.BundleByteLimit = MaxPublishRequestBytes } func (t *Topic) publishMessageBundle(ctx context.Context, bms []*bundledMessage) { pbMsgs := make([]*pb.PubsubMessage, len(bms)) for i, bm := range bms { pbMsgs[i] = &pb.PubsubMessage{ Data: bm.msg.Data, Attributes: bm.msg.Attributes, } bm.msg = nil // release bm.msg for GC } res, err := t.c.pubc.Publish(ctx, &pb.PublishRequest{ Topic: t.name, Messages: pbMsgs, }, gax.WithGRPCOptions(grpc.MaxCallSendMsgSize(maxSendRecvBytes))) for i, bm := range bms { if err != nil { bm.res.set("", err) } else { bm.res.set(res.MessageIds[i], nil) } } } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/LICENSE ================================================ Simplified BSD License Copyright (c) 2016, Datadog All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/bitstream.h ================================================ /* ****************************************************************** bitstream Part of FSE library header file (to include) Copyright (C) 2013-2017, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - Source repository : https://github.com/Cyan4973/FiniteStateEntropy ****************************************************************** */ #ifndef BITSTREAM_H_MODULE #define BITSTREAM_H_MODULE #if defined (__cplusplus) extern "C" { #endif /* * This API consists of small unitary functions, which must be inlined for best performance. * Since link-time-optimization is not available for all compilers, * these functions are defined into a .h to be included. */ /*-**************************************** * Dependencies ******************************************/ #include "mem.h" /* unaligned access routines */ #include "error_private.h" /* error codes and messages */ /*-************************************* * Debug ***************************************/ #if defined(BIT_DEBUG) && (BIT_DEBUG>=1) # include #else # ifndef assert # define assert(condition) ((void)0) # endif #endif /*========================================= * Target specific =========================================*/ #if defined(__BMI__) && defined(__GNUC__) # include /* support for bextr (experimental) */ #endif #define STREAM_ACCUMULATOR_MIN_32 25 #define STREAM_ACCUMULATOR_MIN_64 57 #define STREAM_ACCUMULATOR_MIN ((U32)(MEM_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64)) /*-****************************************** * bitStream encoding API (write forward) ********************************************/ /* bitStream can mix input from multiple sources. * A critical property of these streams is that they encode and decode in **reverse** direction. * So the first bit sequence you add will be the last to be read, like a LIFO stack. */ typedef struct { size_t bitContainer; unsigned bitPos; char* startPtr; char* ptr; char* endPtr; } BIT_CStream_t; MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* dstBuffer, size_t dstCapacity); MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits); MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC); MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC); /* Start with initCStream, providing the size of buffer to write into. * bitStream will never write outside of this buffer. * `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code. * * bits are first added to a local register. * Local register is size_t, hence 64-bits on 64-bits systems, or 32-bits on 32-bits systems. * Writing data into memory is an explicit operation, performed by the flushBits function. * Hence keep track how many bits are potentially stored into local register to avoid register overflow. * After a flushBits, a maximum of 7 bits might still be stored into local register. * * Avoid storing elements of more than 24 bits if you want compatibility with 32-bits bitstream readers. * * Last operation is to close the bitStream. * The function returns the final size of CStream in bytes. * If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable) */ /*-******************************************** * bitStream decoding API (read backward) **********************************************/ typedef struct { size_t bitContainer; unsigned bitsConsumed; const char* ptr; const char* start; const char* limitPtr; } BIT_DStream_t; typedef enum { BIT_DStream_unfinished = 0, BIT_DStream_endOfBuffer = 1, BIT_DStream_completed = 2, BIT_DStream_overflow = 3 } BIT_DStream_status; /* result of BIT_reloadDStream() */ /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize); MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits); MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD); MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD); /* Start by invoking BIT_initDStream(). * A chunk of the bitStream is then stored into a local register. * Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t). * You can then retrieve bitFields stored into the local register, **in reverse order**. * Local register is explicitly reloaded from memory by the BIT_reloadDStream() method. * A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished. * Otherwise, it can be less than that, so proceed accordingly. * Checking if DStream has reached its end can be performed with BIT_endOfDStream(). */ /*-**************************************** * unsafe API ******************************************/ MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits); /* faster, but works only if value is "clean", meaning all high bits above nbBits are 0 */ MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC); /* unsafe version; does not check buffer overflow */ MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits); /* faster, but works only if nbBits >= 1 */ /*-************************************************************** * Internal functions ****************************************************************/ MEM_STATIC unsigned BIT_highbit32 (U32 val) { assert(val != 0); { # if defined(_MSC_VER) /* Visual */ unsigned long r=0; _BitScanReverse ( &r, val ); return (unsigned) r; # elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */ return 31 - __builtin_clz (val); # else /* Software version */ static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; U32 v = val; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; return DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; # endif } } /*===== Local Constants =====*/ static const unsigned BIT_mask[] = { 0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF, 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF, 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF}; /* up to 31 bits */ #define BIT_MASK_SIZE (sizeof(BIT_mask) / sizeof(BIT_mask[0])) /*-************************************************************** * bitStream encoding ****************************************************************/ /*! BIT_initCStream() : * `dstCapacity` must be > sizeof(size_t) * @return : 0 if success, * otherwise an error code (can be tested using ERR_isError()) */ MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* startPtr, size_t dstCapacity) { bitC->bitContainer = 0; bitC->bitPos = 0; bitC->startPtr = (char*)startPtr; bitC->ptr = bitC->startPtr; bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer); if (dstCapacity <= sizeof(bitC->bitContainer)) return ERROR(dstSize_tooSmall); return 0; } /*! BIT_addBits() : * can add up to 31 bits into `bitC`. * Note : does not check for register overflow ! */ MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits) { MEM_STATIC_ASSERT(BIT_MASK_SIZE == 32); assert(nbBits < BIT_MASK_SIZE); assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8); bitC->bitContainer |= (value & BIT_mask[nbBits]) << bitC->bitPos; bitC->bitPos += nbBits; } /*! BIT_addBitsFast() : * works only if `value` is _clean_, meaning all high bits above nbBits are 0 */ MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits) { assert((value>>nbBits) == 0); assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8); bitC->bitContainer |= value << bitC->bitPos; bitC->bitPos += nbBits; } /*! BIT_flushBitsFast() : * assumption : bitContainer has not overflowed * unsafe version; does not check buffer overflow */ MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC) { size_t const nbBytes = bitC->bitPos >> 3; assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8); MEM_writeLEST(bitC->ptr, bitC->bitContainer); bitC->ptr += nbBytes; assert(bitC->ptr <= bitC->endPtr); bitC->bitPos &= 7; bitC->bitContainer >>= nbBytes*8; } /*! BIT_flushBits() : * assumption : bitContainer has not overflowed * safe version; check for buffer overflow, and prevents it. * note : does not signal buffer overflow. * overflow will be revealed later on using BIT_closeCStream() */ MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC) { size_t const nbBytes = bitC->bitPos >> 3; assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8); MEM_writeLEST(bitC->ptr, bitC->bitContainer); bitC->ptr += nbBytes; if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr; bitC->bitPos &= 7; bitC->bitContainer >>= nbBytes*8; } /*! BIT_closeCStream() : * @return : size of CStream, in bytes, * or 0 if it could not fit into dstBuffer */ MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC) { BIT_addBitsFast(bitC, 1, 1); /* endMark */ BIT_flushBits(bitC); if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */ return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0); } /*-******************************************************** * bitStream decoding **********************************************************/ /*! BIT_initDStream() : * Initialize a BIT_DStream_t. * `bitD` : a pointer to an already allocated BIT_DStream_t structure. * `srcSize` must be the *exact* size of the bitStream, in bytes. * @return : size of stream (== srcSize), or an errorCode if a problem is detected */ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize) { if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } bitD->start = (const char*)srcBuffer; bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */ bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); bitD->bitContainer = MEM_readLEST(bitD->ptr); { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */ if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ } } else { bitD->ptr = bitD->start; bitD->bitContainer = *(const BYTE*)(bitD->start); switch(srcSize) { case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16); /* fall-through */ case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24); /* fall-through */ case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32); /* fall-through */ case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; /* fall-through */ case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; /* fall-through */ case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8; /* fall-through */ default: break; } { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; if (lastByte == 0) return ERROR(corruption_detected); /* endMark not present */ } bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; } return srcSize; } MEM_STATIC size_t BIT_getUpperBits(size_t bitContainer, U32 const start) { return bitContainer >> start; } MEM_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits) { #if defined(__BMI__) && defined(__GNUC__) && __GNUC__*1000+__GNUC_MINOR__ >= 4008 /* experimental */ # if defined(__x86_64__) if (sizeof(bitContainer)==8) return _bextr_u64(bitContainer, start, nbBits); else # endif return _bextr_u32(bitContainer, start, nbBits); #else assert(nbBits < BIT_MASK_SIZE); return (bitContainer >> start) & BIT_mask[nbBits]; #endif } MEM_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits) { assert(nbBits < BIT_MASK_SIZE); return bitContainer & BIT_mask[nbBits]; } /*! BIT_lookBits() : * Provides next n bits from local register. * local register is not modified. * On 32-bits, maxNbBits==24. * On 64-bits, maxNbBits==56. * @return : value extracted */ MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits) { #if defined(__BMI__) && defined(__GNUC__) /* experimental; fails if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8 */ return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); #else U32 const regMask = sizeof(bitD->bitContainer)*8 - 1; return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask); #endif } /*! BIT_lookBitsFast() : * unsafe version; only works if nbBits >= 1 */ MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits) { U32 const regMask = sizeof(bitD->bitContainer)*8 - 1; assert(nbBits >= 1); return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); } MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits) { bitD->bitsConsumed += nbBits; } /*! BIT_readBits() : * Read (consume) next n bits from local register and update. * Pay attention to not read more than nbBits contained into local register. * @return : extracted value. */ MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits) { size_t const value = BIT_lookBits(bitD, nbBits); BIT_skipBits(bitD, nbBits); return value; } /*! BIT_readBitsFast() : * unsafe version; only works only if nbBits >= 1 */ MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits) { size_t const value = BIT_lookBitsFast(bitD, nbBits); assert(nbBits >= 1); BIT_skipBits(bitD, nbBits); return value; } /*! BIT_reloadDStream() : * Refill `bitD` from buffer previously set in BIT_initDStream() . * This function is safe, it guarantees it will not read beyond src buffer. * @return : status of `BIT_DStream_t` internal register. * when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */ MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD) { if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ return BIT_DStream_overflow; if (bitD->ptr >= bitD->limitPtr) { bitD->ptr -= bitD->bitsConsumed >> 3; bitD->bitsConsumed &= 7; bitD->bitContainer = MEM_readLEST(bitD->ptr); return BIT_DStream_unfinished; } if (bitD->ptr == bitD->start) { if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; return BIT_DStream_completed; } /* start < ptr < limitPtr */ { U32 nbBytes = bitD->bitsConsumed >> 3; BIT_DStream_status result = BIT_DStream_unfinished; if (bitD->ptr - nbBytes < bitD->start) { nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ result = BIT_DStream_endOfBuffer; } bitD->ptr -= nbBytes; bitD->bitsConsumed -= nbBytes*8; bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ return result; } } /*! BIT_endOfDStream() : * @return : 1 if DStream has _exactly_ reached its end (all bits consumed). */ MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream) { return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8)); } #if defined (__cplusplus) } #endif #endif /* BITSTREAM_H_MODULE */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/compiler.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef ZSTD_COMPILER_H #define ZSTD_COMPILER_H /*-******************************************************* * Compiler specifics *********************************************************/ /* force inlining */ #if defined (__GNUC__) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ # define INLINE_KEYWORD inline #else # define INLINE_KEYWORD #endif #if defined(__GNUC__) # define FORCE_INLINE_ATTR __attribute__((always_inline)) #elif defined(_MSC_VER) # define FORCE_INLINE_ATTR __forceinline #else # define FORCE_INLINE_ATTR #endif /** * FORCE_INLINE_TEMPLATE is used to define C "templates", which take constant * parameters. They must be inlined for the compiler to elimininate the constant * branches. */ #define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR /** * HINT_INLINE is used to help the compiler generate better code. It is *not* * used for "templates", so it can be tweaked based on the compilers * performance. * * gcc-4.8 and gcc-4.9 have been shown to benefit from leaving off the * always_inline attribute. * * clang up to 5.0.0 (trunk) benefit tremendously from the always_inline * attribute. */ #if !defined(__clang__) && defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 8 && __GNUC__ < 5 # define HINT_INLINE static INLINE_KEYWORD #else # define HINT_INLINE static INLINE_KEYWORD FORCE_INLINE_ATTR #endif /* force no inlining */ #ifdef _MSC_VER # define FORCE_NOINLINE static __declspec(noinline) #else # ifdef __GNUC__ # define FORCE_NOINLINE static __attribute__((__noinline__)) # else # define FORCE_NOINLINE static # endif #endif /* target attribute */ #ifndef __has_attribute #define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */ #endif #if defined(__GNUC__) # define TARGET_ATTRIBUTE(target) __attribute__((__target__(target))) #else # define TARGET_ATTRIBUTE(target) #endif /* Enable runtime BMI2 dispatch based on the CPU. * Enabled for clang & gcc >=4.8 on x86 when BMI2 isn't enabled by default. */ #ifndef DYNAMIC_BMI2 #if (defined(__clang__) && __has_attribute(__target__)) \ || (defined(__GNUC__) \ && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))) \ && (defined(__x86_64__) || defined(_M_X86)) \ && !defined(__BMI2__) # define DYNAMIC_BMI2 1 #else # define DYNAMIC_BMI2 0 #endif #endif /* prefetch */ #if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86)) /* _mm_prefetch() is not defined outside of x86/x64 */ # include /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */ # define PREFETCH(ptr) _mm_prefetch((const char*)ptr, _MM_HINT_T0) #elif defined(__GNUC__) # define PREFETCH(ptr) __builtin_prefetch(ptr, 0, 0) #else # define PREFETCH(ptr) /* disabled */ #endif /* disable warnings */ #ifdef _MSC_VER /* Visual Studio */ # include /* For Visual 2005 */ # pragma warning(disable : 4100) /* disable: C4100: unreferenced formal parameter */ # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ # pragma warning(disable : 4204) /* disable: C4204: non-constant aggregate initializer */ # pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */ # pragma warning(disable : 4324) /* disable: C4324: padded structure */ #endif #endif /* ZSTD_COMPILER_H */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/cover.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /* ***************************************************************************** * Constructs a dictionary using a heuristic based on the following paper: * * Liao, Petri, Moffat, Wirth * Effective Construction of Relative Lempel-Ziv Dictionaries * Published in WWW 2016. * * Adapted from code originally written by @ot (Giuseppe Ottaviano). ******************************************************************************/ /*-************************************* * Dependencies ***************************************/ #include /* fprintf */ #include /* malloc, free, qsort */ #include /* memset */ #include /* clock */ #include "mem.h" /* read */ #include "pool.h" #include "threading.h" #include "zstd_internal.h" /* includes zstd.h */ #ifndef ZDICT_STATIC_LINKING_ONLY #define ZDICT_STATIC_LINKING_ONLY #endif #include "zdict.h" /*-************************************* * Constants ***************************************/ #define COVER_MAX_SAMPLES_SIZE (sizeof(size_t) == 8 ? ((U32)-1) : ((U32)1 GB)) /*-************************************* * Console display ***************************************/ static int g_displayLevel = 2; #define DISPLAY(...) \ { \ fprintf(stderr, __VA_ARGS__); \ fflush(stderr); \ } #define LOCALDISPLAYLEVEL(displayLevel, l, ...) \ if (displayLevel >= l) { \ DISPLAY(__VA_ARGS__); \ } /* 0 : no display; 1: errors; 2: default; 3: details; 4: debug */ #define DISPLAYLEVEL(l, ...) LOCALDISPLAYLEVEL(g_displayLevel, l, __VA_ARGS__) #define LOCALDISPLAYUPDATE(displayLevel, l, ...) \ if (displayLevel >= l) { \ if ((clock() - g_time > refreshRate) || (displayLevel >= 4)) { \ g_time = clock(); \ DISPLAY(__VA_ARGS__); \ } \ } #define DISPLAYUPDATE(l, ...) LOCALDISPLAYUPDATE(g_displayLevel, l, __VA_ARGS__) static const clock_t refreshRate = CLOCKS_PER_SEC * 15 / 100; static clock_t g_time = 0; /*-************************************* * Hash table *************************************** * A small specialized hash map for storing activeDmers. * The map does not resize, so if it becomes full it will loop forever. * Thus, the map must be large enough to store every value. * The map implements linear probing and keeps its load less than 0.5. */ #define MAP_EMPTY_VALUE ((U32)-1) typedef struct COVER_map_pair_t_s { U32 key; U32 value; } COVER_map_pair_t; typedef struct COVER_map_s { COVER_map_pair_t *data; U32 sizeLog; U32 size; U32 sizeMask; } COVER_map_t; /** * Clear the map. */ static void COVER_map_clear(COVER_map_t *map) { memset(map->data, MAP_EMPTY_VALUE, map->size * sizeof(COVER_map_pair_t)); } /** * Initializes a map of the given size. * Returns 1 on success and 0 on failure. * The map must be destroyed with COVER_map_destroy(). * The map is only guaranteed to be large enough to hold size elements. */ static int COVER_map_init(COVER_map_t *map, U32 size) { map->sizeLog = ZSTD_highbit32(size) + 2; map->size = (U32)1 << map->sizeLog; map->sizeMask = map->size - 1; map->data = (COVER_map_pair_t *)malloc(map->size * sizeof(COVER_map_pair_t)); if (!map->data) { map->sizeLog = 0; map->size = 0; return 0; } COVER_map_clear(map); return 1; } /** * Internal hash function */ static const U32 prime4bytes = 2654435761U; static U32 COVER_map_hash(COVER_map_t *map, U32 key) { return (key * prime4bytes) >> (32 - map->sizeLog); } /** * Helper function that returns the index that a key should be placed into. */ static U32 COVER_map_index(COVER_map_t *map, U32 key) { const U32 hash = COVER_map_hash(map, key); U32 i; for (i = hash;; i = (i + 1) & map->sizeMask) { COVER_map_pair_t *pos = &map->data[i]; if (pos->value == MAP_EMPTY_VALUE) { return i; } if (pos->key == key) { return i; } } } /** * Returns the pointer to the value for key. * If key is not in the map, it is inserted and the value is set to 0. * The map must not be full. */ static U32 *COVER_map_at(COVER_map_t *map, U32 key) { COVER_map_pair_t *pos = &map->data[COVER_map_index(map, key)]; if (pos->value == MAP_EMPTY_VALUE) { pos->key = key; pos->value = 0; } return &pos->value; } /** * Deletes key from the map if present. */ static void COVER_map_remove(COVER_map_t *map, U32 key) { U32 i = COVER_map_index(map, key); COVER_map_pair_t *del = &map->data[i]; U32 shift = 1; if (del->value == MAP_EMPTY_VALUE) { return; } for (i = (i + 1) & map->sizeMask;; i = (i + 1) & map->sizeMask) { COVER_map_pair_t *const pos = &map->data[i]; /* If the position is empty we are done */ if (pos->value == MAP_EMPTY_VALUE) { del->value = MAP_EMPTY_VALUE; return; } /* If pos can be moved to del do so */ if (((i - COVER_map_hash(map, pos->key)) & map->sizeMask) >= shift) { del->key = pos->key; del->value = pos->value; del = pos; shift = 1; } else { ++shift; } } } /** * Destroyes a map that is inited with COVER_map_init(). */ static void COVER_map_destroy(COVER_map_t *map) { if (map->data) { free(map->data); } map->data = NULL; map->size = 0; } /*-************************************* * Context ***************************************/ typedef struct { const BYTE *samples; size_t *offsets; const size_t *samplesSizes; size_t nbSamples; U32 *suffix; size_t suffixSize; U32 *freqs; U32 *dmerAt; unsigned d; } COVER_ctx_t; /* We need a global context for qsort... */ static COVER_ctx_t *g_ctx = NULL; /*-************************************* * Helper functions ***************************************/ /** * Returns the sum of the sample sizes. */ static size_t COVER_sum(const size_t *samplesSizes, unsigned nbSamples) { size_t sum = 0; size_t i; for (i = 0; i < nbSamples; ++i) { sum += samplesSizes[i]; } return sum; } /** * Returns -1 if the dmer at lp is less than the dmer at rp. * Return 0 if the dmers at lp and rp are equal. * Returns 1 if the dmer at lp is greater than the dmer at rp. */ static int COVER_cmp(COVER_ctx_t *ctx, const void *lp, const void *rp) { U32 const lhs = *(U32 const *)lp; U32 const rhs = *(U32 const *)rp; return memcmp(ctx->samples + lhs, ctx->samples + rhs, ctx->d); } /** * Faster version for d <= 8. */ static int COVER_cmp8(COVER_ctx_t *ctx, const void *lp, const void *rp) { U64 const mask = (ctx->d == 8) ? (U64)-1 : (((U64)1 << (8 * ctx->d)) - 1); U64 const lhs = MEM_readLE64(ctx->samples + *(U32 const *)lp) & mask; U64 const rhs = MEM_readLE64(ctx->samples + *(U32 const *)rp) & mask; if (lhs < rhs) { return -1; } return (lhs > rhs); } /** * Same as COVER_cmp() except ties are broken by pointer value * NOTE: g_ctx must be set to call this function. A global is required because * qsort doesn't take an opaque pointer. */ static int COVER_strict_cmp(const void *lp, const void *rp) { int result = COVER_cmp(g_ctx, lp, rp); if (result == 0) { result = lp < rp ? -1 : 1; } return result; } /** * Faster version for d <= 8. */ static int COVER_strict_cmp8(const void *lp, const void *rp) { int result = COVER_cmp8(g_ctx, lp, rp); if (result == 0) { result = lp < rp ? -1 : 1; } return result; } /** * Returns the first pointer in [first, last) whose element does not compare * less than value. If no such element exists it returns last. */ static const size_t *COVER_lower_bound(const size_t *first, const size_t *last, size_t value) { size_t count = last - first; while (count != 0) { size_t step = count / 2; const size_t *ptr = first; ptr += step; if (*ptr < value) { first = ++ptr; count -= step + 1; } else { count = step; } } return first; } /** * Generic groupBy function. * Groups an array sorted by cmp into groups with equivalent values. * Calls grp for each group. */ static void COVER_groupBy(const void *data, size_t count, size_t size, COVER_ctx_t *ctx, int (*cmp)(COVER_ctx_t *, const void *, const void *), void (*grp)(COVER_ctx_t *, const void *, const void *)) { const BYTE *ptr = (const BYTE *)data; size_t num = 0; while (num < count) { const BYTE *grpEnd = ptr + size; ++num; while (num < count && cmp(ctx, ptr, grpEnd) == 0) { grpEnd += size; ++num; } grp(ctx, ptr, grpEnd); ptr = grpEnd; } } /*-************************************* * Cover functions ***************************************/ /** * Called on each group of positions with the same dmer. * Counts the frequency of each dmer and saves it in the suffix array. * Fills `ctx->dmerAt`. */ static void COVER_group(COVER_ctx_t *ctx, const void *group, const void *groupEnd) { /* The group consists of all the positions with the same first d bytes. */ const U32 *grpPtr = (const U32 *)group; const U32 *grpEnd = (const U32 *)groupEnd; /* The dmerId is how we will reference this dmer. * This allows us to map the whole dmer space to a much smaller space, the * size of the suffix array. */ const U32 dmerId = (U32)(grpPtr - ctx->suffix); /* Count the number of samples this dmer shows up in */ U32 freq = 0; /* Details */ const size_t *curOffsetPtr = ctx->offsets; const size_t *offsetsEnd = ctx->offsets + ctx->nbSamples; /* Once *grpPtr >= curSampleEnd this occurrence of the dmer is in a * different sample than the last. */ size_t curSampleEnd = ctx->offsets[0]; for (; grpPtr != grpEnd; ++grpPtr) { /* Save the dmerId for this position so we can get back to it. */ ctx->dmerAt[*grpPtr] = dmerId; /* Dictionaries only help for the first reference to the dmer. * After that zstd can reference the match from the previous reference. * So only count each dmer once for each sample it is in. */ if (*grpPtr < curSampleEnd) { continue; } freq += 1; /* Binary search to find the end of the sample *grpPtr is in. * In the common case that grpPtr + 1 == grpEnd we can skip the binary * search because the loop is over. */ if (grpPtr + 1 != grpEnd) { const size_t *sampleEndPtr = COVER_lower_bound(curOffsetPtr, offsetsEnd, *grpPtr); curSampleEnd = *sampleEndPtr; curOffsetPtr = sampleEndPtr + 1; } } /* At this point we are never going to look at this segment of the suffix * array again. We take advantage of this fact to save memory. * We store the frequency of the dmer in the first position of the group, * which is dmerId. */ ctx->suffix[dmerId] = freq; } /** * A segment is a range in the source as well as the score of the segment. */ typedef struct { U32 begin; U32 end; U32 score; } COVER_segment_t; /** * Selects the best segment in an epoch. * Segments of are scored according to the function: * * Let F(d) be the frequency of dmer d. * Let S_i be the dmer at position i of segment S which has length k. * * Score(S) = F(S_1) + F(S_2) + ... + F(S_{k-d+1}) * * Once the dmer d is in the dictionay we set F(d) = 0. */ static COVER_segment_t COVER_selectSegment(const COVER_ctx_t *ctx, U32 *freqs, COVER_map_t *activeDmers, U32 begin, U32 end, ZDICT_cover_params_t parameters) { /* Constants */ const U32 k = parameters.k; const U32 d = parameters.d; const U32 dmersInK = k - d + 1; /* Try each segment (activeSegment) and save the best (bestSegment) */ COVER_segment_t bestSegment = {0, 0, 0}; COVER_segment_t activeSegment; /* Reset the activeDmers in the segment */ COVER_map_clear(activeDmers); /* The activeSegment starts at the beginning of the epoch. */ activeSegment.begin = begin; activeSegment.end = begin; activeSegment.score = 0; /* Slide the activeSegment through the whole epoch. * Save the best segment in bestSegment. */ while (activeSegment.end < end) { /* The dmerId for the dmer at the next position */ U32 newDmer = ctx->dmerAt[activeSegment.end]; /* The entry in activeDmers for this dmerId */ U32 *newDmerOcc = COVER_map_at(activeDmers, newDmer); /* If the dmer isn't already present in the segment add its score. */ if (*newDmerOcc == 0) { /* The paper suggest using the L-0.5 norm, but experiments show that it * doesn't help. */ activeSegment.score += freqs[newDmer]; } /* Add the dmer to the segment */ activeSegment.end += 1; *newDmerOcc += 1; /* If the window is now too large, drop the first position */ if (activeSegment.end - activeSegment.begin == dmersInK + 1) { U32 delDmer = ctx->dmerAt[activeSegment.begin]; U32 *delDmerOcc = COVER_map_at(activeDmers, delDmer); activeSegment.begin += 1; *delDmerOcc -= 1; /* If this is the last occurence of the dmer, subtract its score */ if (*delDmerOcc == 0) { COVER_map_remove(activeDmers, delDmer); activeSegment.score -= freqs[delDmer]; } } /* If this segment is the best so far save it */ if (activeSegment.score > bestSegment.score) { bestSegment = activeSegment; } } { /* Trim off the zero frequency head and tail from the segment. */ U32 newBegin = bestSegment.end; U32 newEnd = bestSegment.begin; U32 pos; for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) { U32 freq = freqs[ctx->dmerAt[pos]]; if (freq != 0) { newBegin = MIN(newBegin, pos); newEnd = pos + 1; } } bestSegment.begin = newBegin; bestSegment.end = newEnd; } { /* Zero out the frequency of each dmer covered by the chosen segment. */ U32 pos; for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) { freqs[ctx->dmerAt[pos]] = 0; } } return bestSegment; } /** * Check the validity of the parameters. * Returns non-zero if the parameters are valid and 0 otherwise. */ static int COVER_checkParameters(ZDICT_cover_params_t parameters, size_t maxDictSize) { /* k and d are required parameters */ if (parameters.d == 0 || parameters.k == 0) { return 0; } /* k <= maxDictSize */ if (parameters.k > maxDictSize) { return 0; } /* d <= k */ if (parameters.d > parameters.k) { return 0; } return 1; } /** * Clean up a context initialized with `COVER_ctx_init()`. */ static void COVER_ctx_destroy(COVER_ctx_t *ctx) { if (!ctx) { return; } if (ctx->suffix) { free(ctx->suffix); ctx->suffix = NULL; } if (ctx->freqs) { free(ctx->freqs); ctx->freqs = NULL; } if (ctx->dmerAt) { free(ctx->dmerAt); ctx->dmerAt = NULL; } if (ctx->offsets) { free(ctx->offsets); ctx->offsets = NULL; } } /** * Prepare a context for dictionary building. * The context is only dependent on the parameter `d` and can used multiple * times. * Returns 1 on success or zero on error. * The context must be destroyed with `COVER_ctx_destroy()`. */ static int COVER_ctx_init(COVER_ctx_t *ctx, const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples, unsigned d) { const BYTE *const samples = (const BYTE *)samplesBuffer; const size_t totalSamplesSize = COVER_sum(samplesSizes, nbSamples); /* Checks */ if (totalSamplesSize < MAX(d, sizeof(U64)) || totalSamplesSize >= (size_t)COVER_MAX_SAMPLES_SIZE) { DISPLAYLEVEL(1, "Total samples size is too large (%u MB), maximum size is %u MB\n", (U32)(totalSamplesSize>>20), (COVER_MAX_SAMPLES_SIZE >> 20)); return 0; } /* Zero the context */ memset(ctx, 0, sizeof(*ctx)); DISPLAYLEVEL(2, "Training on %u samples of total size %u\n", nbSamples, (U32)totalSamplesSize); ctx->samples = samples; ctx->samplesSizes = samplesSizes; ctx->nbSamples = nbSamples; /* Partial suffix array */ ctx->suffixSize = totalSamplesSize - MAX(d, sizeof(U64)) + 1; ctx->suffix = (U32 *)malloc(ctx->suffixSize * sizeof(U32)); /* Maps index to the dmerID */ ctx->dmerAt = (U32 *)malloc(ctx->suffixSize * sizeof(U32)); /* The offsets of each file */ ctx->offsets = (size_t *)malloc((nbSamples + 1) * sizeof(size_t)); if (!ctx->suffix || !ctx->dmerAt || !ctx->offsets) { DISPLAYLEVEL(1, "Failed to allocate scratch buffers\n"); COVER_ctx_destroy(ctx); return 0; } ctx->freqs = NULL; ctx->d = d; /* Fill offsets from the samlesSizes */ { U32 i; ctx->offsets[0] = 0; for (i = 1; i <= nbSamples; ++i) { ctx->offsets[i] = ctx->offsets[i - 1] + samplesSizes[i - 1]; } } DISPLAYLEVEL(2, "Constructing partial suffix array\n"); { /* suffix is a partial suffix array. * It only sorts suffixes by their first parameters.d bytes. * The sort is stable, so each dmer group is sorted by position in input. */ U32 i; for (i = 0; i < ctx->suffixSize; ++i) { ctx->suffix[i] = i; } /* qsort doesn't take an opaque pointer, so pass as a global */ g_ctx = ctx; qsort(ctx->suffix, ctx->suffixSize, sizeof(U32), (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp)); } DISPLAYLEVEL(2, "Computing frequencies\n"); /* For each dmer group (group of positions with the same first d bytes): * 1. For each position we set dmerAt[position] = dmerID. The dmerID is * (groupBeginPtr - suffix). This allows us to go from position to * dmerID so we can look up values in freq. * 2. We calculate how many samples the dmer occurs in and save it in * freqs[dmerId]. */ COVER_groupBy(ctx->suffix, ctx->suffixSize, sizeof(U32), ctx, (ctx->d <= 8 ? &COVER_cmp8 : &COVER_cmp), &COVER_group); ctx->freqs = ctx->suffix; ctx->suffix = NULL; return 1; } /** * Given the prepared context build the dictionary. */ static size_t COVER_buildDictionary(const COVER_ctx_t *ctx, U32 *freqs, COVER_map_t *activeDmers, void *dictBuffer, size_t dictBufferCapacity, ZDICT_cover_params_t parameters) { BYTE *const dict = (BYTE *)dictBuffer; size_t tail = dictBufferCapacity; /* Divide the data up into epochs of equal size. * We will select at least one segment from each epoch. */ const U32 epochs = (U32)(dictBufferCapacity / parameters.k); const U32 epochSize = (U32)(ctx->suffixSize / epochs); size_t epoch; DISPLAYLEVEL(2, "Breaking content into %u epochs of size %u\n", epochs, epochSize); /* Loop through the epochs until there are no more segments or the dictionary * is full. */ for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs) { const U32 epochBegin = (U32)(epoch * epochSize); const U32 epochEnd = epochBegin + epochSize; size_t segmentSize; /* Select a segment */ COVER_segment_t segment = COVER_selectSegment( ctx, freqs, activeDmers, epochBegin, epochEnd, parameters); /* If the segment covers no dmers, then we are out of content */ if (segment.score == 0) { break; } /* Trim the segment if necessary and if it is too small then we are done */ segmentSize = MIN(segment.end - segment.begin + parameters.d - 1, tail); if (segmentSize < parameters.d) { break; } /* We fill the dictionary from the back to allow the best segments to be * referenced with the smallest offsets. */ tail -= segmentSize; memcpy(dict + tail, ctx->samples + segment.begin, segmentSize); DISPLAYUPDATE( 2, "\r%u%% ", (U32)(((dictBufferCapacity - tail) * 100) / dictBufferCapacity)); } DISPLAYLEVEL(2, "\r%79s\r", ""); return tail; } ZDICTLIB_API size_t ZDICT_trainFromBuffer_cover( void *dictBuffer, size_t dictBufferCapacity, const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples, ZDICT_cover_params_t parameters) { BYTE* const dict = (BYTE*)dictBuffer; COVER_ctx_t ctx; COVER_map_t activeDmers; /* Initialize global data */ g_displayLevel = parameters.zParams.notificationLevel; /* Checks */ if (!COVER_checkParameters(parameters, dictBufferCapacity)) { DISPLAYLEVEL(1, "Cover parameters incorrect\n"); return ERROR(GENERIC); } if (nbSamples == 0) { DISPLAYLEVEL(1, "Cover must have at least one input file\n"); return ERROR(GENERIC); } if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) { DISPLAYLEVEL(1, "dictBufferCapacity must be at least %u\n", ZDICT_DICTSIZE_MIN); return ERROR(dstSize_tooSmall); } /* Initialize context and activeDmers */ if (!COVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples, parameters.d)) { return ERROR(GENERIC); } if (!COVER_map_init(&activeDmers, parameters.k - parameters.d + 1)) { DISPLAYLEVEL(1, "Failed to allocate dmer map: out of memory\n"); COVER_ctx_destroy(&ctx); return ERROR(GENERIC); } DISPLAYLEVEL(2, "Building dictionary\n"); { const size_t tail = COVER_buildDictionary(&ctx, ctx.freqs, &activeDmers, dictBuffer, dictBufferCapacity, parameters); const size_t dictionarySize = ZDICT_finalizeDictionary( dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail, samplesBuffer, samplesSizes, nbSamples, parameters.zParams); if (!ZSTD_isError(dictionarySize)) { DISPLAYLEVEL(2, "Constructed dictionary of size %u\n", (U32)dictionarySize); } COVER_ctx_destroy(&ctx); COVER_map_destroy(&activeDmers); return dictionarySize; } } /** * COVER_best_t is used for two purposes: * 1. Synchronizing threads. * 2. Saving the best parameters and dictionary. * * All of the methods except COVER_best_init() are thread safe if zstd is * compiled with multithreaded support. */ typedef struct COVER_best_s { ZSTD_pthread_mutex_t mutex; ZSTD_pthread_cond_t cond; size_t liveJobs; void *dict; size_t dictSize; ZDICT_cover_params_t parameters; size_t compressedSize; } COVER_best_t; /** * Initialize the `COVER_best_t`. */ static void COVER_best_init(COVER_best_t *best) { if (best==NULL) return; /* compatible with init on NULL */ (void)ZSTD_pthread_mutex_init(&best->mutex, NULL); (void)ZSTD_pthread_cond_init(&best->cond, NULL); best->liveJobs = 0; best->dict = NULL; best->dictSize = 0; best->compressedSize = (size_t)-1; memset(&best->parameters, 0, sizeof(best->parameters)); } /** * Wait until liveJobs == 0. */ static void COVER_best_wait(COVER_best_t *best) { if (!best) { return; } ZSTD_pthread_mutex_lock(&best->mutex); while (best->liveJobs != 0) { ZSTD_pthread_cond_wait(&best->cond, &best->mutex); } ZSTD_pthread_mutex_unlock(&best->mutex); } /** * Call COVER_best_wait() and then destroy the COVER_best_t. */ static void COVER_best_destroy(COVER_best_t *best) { if (!best) { return; } COVER_best_wait(best); if (best->dict) { free(best->dict); } ZSTD_pthread_mutex_destroy(&best->mutex); ZSTD_pthread_cond_destroy(&best->cond); } /** * Called when a thread is about to be launched. * Increments liveJobs. */ static void COVER_best_start(COVER_best_t *best) { if (!best) { return; } ZSTD_pthread_mutex_lock(&best->mutex); ++best->liveJobs; ZSTD_pthread_mutex_unlock(&best->mutex); } /** * Called when a thread finishes executing, both on error or success. * Decrements liveJobs and signals any waiting threads if liveJobs == 0. * If this dictionary is the best so far save it and its parameters. */ static void COVER_best_finish(COVER_best_t *best, size_t compressedSize, ZDICT_cover_params_t parameters, void *dict, size_t dictSize) { if (!best) { return; } { size_t liveJobs; ZSTD_pthread_mutex_lock(&best->mutex); --best->liveJobs; liveJobs = best->liveJobs; /* If the new dictionary is better */ if (compressedSize < best->compressedSize) { /* Allocate space if necessary */ if (!best->dict || best->dictSize < dictSize) { if (best->dict) { free(best->dict); } best->dict = malloc(dictSize); if (!best->dict) { best->compressedSize = ERROR(GENERIC); best->dictSize = 0; return; } } /* Save the dictionary, parameters, and size */ memcpy(best->dict, dict, dictSize); best->dictSize = dictSize; best->parameters = parameters; best->compressedSize = compressedSize; } ZSTD_pthread_mutex_unlock(&best->mutex); if (liveJobs == 0) { ZSTD_pthread_cond_broadcast(&best->cond); } } } /** * Parameters for COVER_tryParameters(). */ typedef struct COVER_tryParameters_data_s { const COVER_ctx_t *ctx; COVER_best_t *best; size_t dictBufferCapacity; ZDICT_cover_params_t parameters; } COVER_tryParameters_data_t; /** * Tries a set of parameters and upates the COVER_best_t with the results. * This function is thread safe if zstd is compiled with multithreaded support. * It takes its parameters as an *OWNING* opaque pointer to support threading. */ static void COVER_tryParameters(void *opaque) { /* Save parameters as local variables */ COVER_tryParameters_data_t *const data = (COVER_tryParameters_data_t *)opaque; const COVER_ctx_t *const ctx = data->ctx; const ZDICT_cover_params_t parameters = data->parameters; size_t dictBufferCapacity = data->dictBufferCapacity; size_t totalCompressedSize = ERROR(GENERIC); /* Allocate space for hash table, dict, and freqs */ COVER_map_t activeDmers; BYTE *const dict = (BYTE * const)malloc(dictBufferCapacity); U32 *freqs = (U32 *)malloc(ctx->suffixSize * sizeof(U32)); if (!COVER_map_init(&activeDmers, parameters.k - parameters.d + 1)) { DISPLAYLEVEL(1, "Failed to allocate dmer map: out of memory\n"); goto _cleanup; } if (!dict || !freqs) { DISPLAYLEVEL(1, "Failed to allocate buffers: out of memory\n"); goto _cleanup; } /* Copy the frequencies because we need to modify them */ memcpy(freqs, ctx->freqs, ctx->suffixSize * sizeof(U32)); /* Build the dictionary */ { const size_t tail = COVER_buildDictionary(ctx, freqs, &activeDmers, dict, dictBufferCapacity, parameters); dictBufferCapacity = ZDICT_finalizeDictionary( dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail, ctx->samples, ctx->samplesSizes, (unsigned)ctx->nbSamples, parameters.zParams); if (ZDICT_isError(dictBufferCapacity)) { DISPLAYLEVEL(1, "Failed to finalize dictionary\n"); goto _cleanup; } } /* Check total compressed size */ { /* Pointers */ ZSTD_CCtx *cctx; ZSTD_CDict *cdict; void *dst; /* Local variables */ size_t dstCapacity; size_t i; /* Allocate dst with enough space to compress the maximum sized sample */ { size_t maxSampleSize = 0; for (i = 0; i < ctx->nbSamples; ++i) { maxSampleSize = MAX(ctx->samplesSizes[i], maxSampleSize); } dstCapacity = ZSTD_compressBound(maxSampleSize); dst = malloc(dstCapacity); } /* Create the cctx and cdict */ cctx = ZSTD_createCCtx(); cdict = ZSTD_createCDict(dict, dictBufferCapacity, parameters.zParams.compressionLevel); if (!dst || !cctx || !cdict) { goto _compressCleanup; } /* Compress each sample and sum their sizes (or error) */ totalCompressedSize = dictBufferCapacity; for (i = 0; i < ctx->nbSamples; ++i) { const size_t size = ZSTD_compress_usingCDict( cctx, dst, dstCapacity, ctx->samples + ctx->offsets[i], ctx->samplesSizes[i], cdict); if (ZSTD_isError(size)) { totalCompressedSize = ERROR(GENERIC); goto _compressCleanup; } totalCompressedSize += size; } _compressCleanup: ZSTD_freeCCtx(cctx); ZSTD_freeCDict(cdict); if (dst) { free(dst); } } _cleanup: COVER_best_finish(data->best, totalCompressedSize, parameters, dict, dictBufferCapacity); free(data); COVER_map_destroy(&activeDmers); if (dict) { free(dict); } if (freqs) { free(freqs); } } ZDICTLIB_API size_t ZDICT_optimizeTrainFromBuffer_cover( void *dictBuffer, size_t dictBufferCapacity, const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples, ZDICT_cover_params_t *parameters) { /* constants */ const unsigned nbThreads = parameters->nbThreads; const unsigned kMinD = parameters->d == 0 ? 6 : parameters->d; const unsigned kMaxD = parameters->d == 0 ? 8 : parameters->d; const unsigned kMinK = parameters->k == 0 ? 50 : parameters->k; const unsigned kMaxK = parameters->k == 0 ? 2000 : parameters->k; const unsigned kSteps = parameters->steps == 0 ? 40 : parameters->steps; const unsigned kStepSize = MAX((kMaxK - kMinK) / kSteps, 1); const unsigned kIterations = (1 + (kMaxD - kMinD) / 2) * (1 + (kMaxK - kMinK) / kStepSize); /* Local variables */ const int displayLevel = parameters->zParams.notificationLevel; unsigned iteration = 1; unsigned d; unsigned k; COVER_best_t best; POOL_ctx *pool = NULL; /* Checks */ if (kMinK < kMaxD || kMaxK < kMinK) { LOCALDISPLAYLEVEL(displayLevel, 1, "Incorrect parameters\n"); return ERROR(GENERIC); } if (nbSamples == 0) { DISPLAYLEVEL(1, "Cover must have at least one input file\n"); return ERROR(GENERIC); } if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) { DISPLAYLEVEL(1, "dictBufferCapacity must be at least %u\n", ZDICT_DICTSIZE_MIN); return ERROR(dstSize_tooSmall); } if (nbThreads > 1) { pool = POOL_create(nbThreads, 1); if (!pool) { return ERROR(memory_allocation); } } /* Initialization */ COVER_best_init(&best); /* Turn down global display level to clean up display at level 2 and below */ g_displayLevel = displayLevel == 0 ? 0 : displayLevel - 1; /* Loop through d first because each new value needs a new context */ LOCALDISPLAYLEVEL(displayLevel, 2, "Trying %u different sets of parameters\n", kIterations); for (d = kMinD; d <= kMaxD; d += 2) { /* Initialize the context for this value of d */ COVER_ctx_t ctx; LOCALDISPLAYLEVEL(displayLevel, 3, "d=%u\n", d); if (!COVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples, d)) { LOCALDISPLAYLEVEL(displayLevel, 1, "Failed to initialize context\n"); COVER_best_destroy(&best); POOL_free(pool); return ERROR(GENERIC); } /* Loop through k reusing the same context */ for (k = kMinK; k <= kMaxK; k += kStepSize) { /* Prepare the arguments */ COVER_tryParameters_data_t *data = (COVER_tryParameters_data_t *)malloc( sizeof(COVER_tryParameters_data_t)); LOCALDISPLAYLEVEL(displayLevel, 3, "k=%u\n", k); if (!data) { LOCALDISPLAYLEVEL(displayLevel, 1, "Failed to allocate parameters\n"); COVER_best_destroy(&best); COVER_ctx_destroy(&ctx); POOL_free(pool); return ERROR(GENERIC); } data->ctx = &ctx; data->best = &best; data->dictBufferCapacity = dictBufferCapacity; data->parameters = *parameters; data->parameters.k = k; data->parameters.d = d; data->parameters.steps = kSteps; data->parameters.zParams.notificationLevel = g_displayLevel; /* Check the parameters */ if (!COVER_checkParameters(data->parameters, dictBufferCapacity)) { DISPLAYLEVEL(1, "Cover parameters incorrect\n"); free(data); continue; } /* Call the function and pass ownership of data to it */ COVER_best_start(&best); if (pool) { POOL_add(pool, &COVER_tryParameters, data); } else { COVER_tryParameters(data); } /* Print status */ LOCALDISPLAYUPDATE(displayLevel, 2, "\r%u%% ", (U32)((iteration * 100) / kIterations)); ++iteration; } COVER_best_wait(&best); COVER_ctx_destroy(&ctx); } LOCALDISPLAYLEVEL(displayLevel, 2, "\r%79s\r", ""); /* Fill the output buffer and parameters with output of the best parameters */ { const size_t dictSize = best.dictSize; if (ZSTD_isError(best.compressedSize)) { const size_t compressedSize = best.compressedSize; COVER_best_destroy(&best); POOL_free(pool); return compressedSize; } *parameters = best.parameters; memcpy(dictBuffer, best.dict, dictSize); COVER_best_destroy(&best); POOL_free(pool); return dictSize; } } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/cpu.h ================================================ /* * Copyright (c) 2018-present, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef ZSTD_COMMON_CPU_H #define ZSTD_COMMON_CPU_H /** * Implementation taken from folly/CpuId.h * https://github.com/facebook/folly/blob/master/folly/CpuId.h */ #include #include "mem.h" #ifdef _MSC_VER #include #endif typedef struct { U32 f1c; U32 f1d; U32 f7b; U32 f7c; } ZSTD_cpuid_t; MEM_STATIC ZSTD_cpuid_t ZSTD_cpuid(void) { U32 f1c = 0; U32 f1d = 0; U32 f7b = 0; U32 f7c = 0; #ifdef _MSC_VER int reg[4]; __cpuid((int*)reg, 0); { int const n = reg[0]; if (n >= 1) { __cpuid((int*)reg, 1); f1c = (U32)reg[2]; f1d = (U32)reg[3]; } if (n >= 7) { __cpuidex((int*)reg, 7, 0); f7b = (U32)reg[1]; f7c = (U32)reg[2]; } } #elif defined(__i386__) && defined(__PIC__) && !defined(__clang__) && defined(__GNUC__) /* The following block like the normal cpuid branch below, but gcc * reserves ebx for use of its pic register so we must specially * handle the save and restore to avoid clobbering the register */ U32 n; __asm__( "pushl %%ebx\n\t" "cpuid\n\t" "popl %%ebx\n\t" : "=a"(n) : "a"(0) : "ecx", "edx"); if (n >= 1) { U32 f1a; __asm__( "pushl %%ebx\n\t" "cpuid\n\t" "popl %%ebx\n\t" : "=a"(f1a), "=c"(f1c), "=d"(f1d) : "a"(1) :); } if (n >= 7) { __asm__( "pushl %%ebx\n\t" "cpuid\n\t" "movl %%ebx, %%eax\n\r" "popl %%ebx" : "=a"(f7b), "=c"(f7c) : "a"(7), "c"(0) : "edx"); } #elif defined(__x86_64__) || defined(_M_X64) || defined(__i386__) U32 n; __asm__("cpuid" : "=a"(n) : "a"(0) : "ebx", "ecx", "edx"); if (n >= 1) { U32 f1a; __asm__("cpuid" : "=a"(f1a), "=c"(f1c), "=d"(f1d) : "a"(1) : "ebx"); } if (n >= 7) { U32 f7a; __asm__("cpuid" : "=a"(f7a), "=b"(f7b), "=c"(f7c) : "a"(7), "c"(0) : "edx"); } #endif { ZSTD_cpuid_t cpuid; cpuid.f1c = f1c; cpuid.f1d = f1d; cpuid.f7b = f7b; cpuid.f7c = f7c; return cpuid; } } #define X(name, r, bit) \ MEM_STATIC int ZSTD_cpuid_##name(ZSTD_cpuid_t const cpuid) { \ return ((cpuid.r) & (1U << bit)) != 0; \ } /* cpuid(1): Processor Info and Feature Bits. */ #define C(name, bit) X(name, f1c, bit) C(sse3, 0) C(pclmuldq, 1) C(dtes64, 2) C(monitor, 3) C(dscpl, 4) C(vmx, 5) C(smx, 6) C(eist, 7) C(tm2, 8) C(ssse3, 9) C(cnxtid, 10) C(fma, 12) C(cx16, 13) C(xtpr, 14) C(pdcm, 15) C(pcid, 17) C(dca, 18) C(sse41, 19) C(sse42, 20) C(x2apic, 21) C(movbe, 22) C(popcnt, 23) C(tscdeadline, 24) C(aes, 25) C(xsave, 26) C(osxsave, 27) C(avx, 28) C(f16c, 29) C(rdrand, 30) #undef C #define D(name, bit) X(name, f1d, bit) D(fpu, 0) D(vme, 1) D(de, 2) D(pse, 3) D(tsc, 4) D(msr, 5) D(pae, 6) D(mce, 7) D(cx8, 8) D(apic, 9) D(sep, 11) D(mtrr, 12) D(pge, 13) D(mca, 14) D(cmov, 15) D(pat, 16) D(pse36, 17) D(psn, 18) D(clfsh, 19) D(ds, 21) D(acpi, 22) D(mmx, 23) D(fxsr, 24) D(sse, 25) D(sse2, 26) D(ss, 27) D(htt, 28) D(tm, 29) D(pbe, 31) #undef D /* cpuid(7): Extended Features. */ #define B(name, bit) X(name, f7b, bit) B(bmi1, 3) B(hle, 4) B(avx2, 5) B(smep, 7) B(bmi2, 8) B(erms, 9) B(invpcid, 10) B(rtm, 11) B(mpx, 14) B(avx512f, 16) B(avx512dq, 17) B(rdseed, 18) B(adx, 19) B(smap, 20) B(avx512ifma, 21) B(pcommit, 22) B(clflushopt, 23) B(clwb, 24) B(avx512pf, 26) B(avx512er, 27) B(avx512cd, 28) B(sha, 29) B(avx512bw, 30) B(avx512vl, 31) #undef B #define C(name, bit) X(name, f7c, bit) C(prefetchwt1, 0) C(avx512vbmi, 1) #undef C #undef X #endif /* ZSTD_COMMON_CPU_H */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/divsufsort.c ================================================ /* * divsufsort.c for libdivsufsort-lite * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved. * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /*- Compiler specifics -*/ #ifdef __clang__ #pragma clang diagnostic ignored "-Wshorten-64-to-32" #endif #if defined(_MSC_VER) # pragma warning(disable : 4244) # pragma warning(disable : 4127) /* C4127 : Condition expression is constant */ #endif /*- Dependencies -*/ #include #include #include #include "divsufsort.h" /*- Constants -*/ #if defined(INLINE) # undef INLINE #endif #if !defined(INLINE) # define INLINE __inline #endif #if defined(ALPHABET_SIZE) && (ALPHABET_SIZE < 1) # undef ALPHABET_SIZE #endif #if !defined(ALPHABET_SIZE) # define ALPHABET_SIZE (256) #endif #define BUCKET_A_SIZE (ALPHABET_SIZE) #define BUCKET_B_SIZE (ALPHABET_SIZE * ALPHABET_SIZE) #if defined(SS_INSERTIONSORT_THRESHOLD) # if SS_INSERTIONSORT_THRESHOLD < 1 # undef SS_INSERTIONSORT_THRESHOLD # define SS_INSERTIONSORT_THRESHOLD (1) # endif #else # define SS_INSERTIONSORT_THRESHOLD (8) #endif #if defined(SS_BLOCKSIZE) # if SS_BLOCKSIZE < 0 # undef SS_BLOCKSIZE # define SS_BLOCKSIZE (0) # elif 32768 <= SS_BLOCKSIZE # undef SS_BLOCKSIZE # define SS_BLOCKSIZE (32767) # endif #else # define SS_BLOCKSIZE (1024) #endif /* minstacksize = log(SS_BLOCKSIZE) / log(3) * 2 */ #if SS_BLOCKSIZE == 0 # define SS_MISORT_STACKSIZE (96) #elif SS_BLOCKSIZE <= 4096 # define SS_MISORT_STACKSIZE (16) #else # define SS_MISORT_STACKSIZE (24) #endif #define SS_SMERGE_STACKSIZE (32) #define TR_INSERTIONSORT_THRESHOLD (8) #define TR_STACKSIZE (64) /*- Macros -*/ #ifndef SWAP # define SWAP(_a, _b) do { t = (_a); (_a) = (_b); (_b) = t; } while(0) #endif /* SWAP */ #ifndef MIN # define MIN(_a, _b) (((_a) < (_b)) ? (_a) : (_b)) #endif /* MIN */ #ifndef MAX # define MAX(_a, _b) (((_a) > (_b)) ? (_a) : (_b)) #endif /* MAX */ #define STACK_PUSH(_a, _b, _c, _d)\ do {\ assert(ssize < STACK_SIZE);\ stack[ssize].a = (_a), stack[ssize].b = (_b),\ stack[ssize].c = (_c), stack[ssize++].d = (_d);\ } while(0) #define STACK_PUSH5(_a, _b, _c, _d, _e)\ do {\ assert(ssize < STACK_SIZE);\ stack[ssize].a = (_a), stack[ssize].b = (_b),\ stack[ssize].c = (_c), stack[ssize].d = (_d), stack[ssize++].e = (_e);\ } while(0) #define STACK_POP(_a, _b, _c, _d)\ do {\ assert(0 <= ssize);\ if(ssize == 0) { return; }\ (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\ (_c) = stack[ssize].c, (_d) = stack[ssize].d;\ } while(0) #define STACK_POP5(_a, _b, _c, _d, _e)\ do {\ assert(0 <= ssize);\ if(ssize == 0) { return; }\ (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\ (_c) = stack[ssize].c, (_d) = stack[ssize].d, (_e) = stack[ssize].e;\ } while(0) #define BUCKET_A(_c0) bucket_A[(_c0)] #if ALPHABET_SIZE == 256 #define BUCKET_B(_c0, _c1) (bucket_B[((_c1) << 8) | (_c0)]) #define BUCKET_BSTAR(_c0, _c1) (bucket_B[((_c0) << 8) | (_c1)]) #else #define BUCKET_B(_c0, _c1) (bucket_B[(_c1) * ALPHABET_SIZE + (_c0)]) #define BUCKET_BSTAR(_c0, _c1) (bucket_B[(_c0) * ALPHABET_SIZE + (_c1)]) #endif /*- Private Functions -*/ static const int lg_table[256]= { -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7 }; #if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) static INLINE int ss_ilg(int n) { #if SS_BLOCKSIZE == 0 return (n & 0xffff0000) ? ((n & 0xff000000) ? 24 + lg_table[(n >> 24) & 0xff] : 16 + lg_table[(n >> 16) & 0xff]) : ((n & 0x0000ff00) ? 8 + lg_table[(n >> 8) & 0xff] : 0 + lg_table[(n >> 0) & 0xff]); #elif SS_BLOCKSIZE < 256 return lg_table[n]; #else return (n & 0xff00) ? 8 + lg_table[(n >> 8) & 0xff] : 0 + lg_table[(n >> 0) & 0xff]; #endif } #endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */ #if SS_BLOCKSIZE != 0 static const int sqq_table[256] = { 0, 16, 22, 27, 32, 35, 39, 42, 45, 48, 50, 53, 55, 57, 59, 61, 64, 65, 67, 69, 71, 73, 75, 76, 78, 80, 81, 83, 84, 86, 87, 89, 90, 91, 93, 94, 96, 97, 98, 99, 101, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 128, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 144, 145, 146, 147, 148, 149, 150, 150, 151, 152, 153, 154, 155, 155, 156, 157, 158, 159, 160, 160, 161, 162, 163, 163, 164, 165, 166, 167, 167, 168, 169, 170, 170, 171, 172, 173, 173, 174, 175, 176, 176, 177, 178, 178, 179, 180, 181, 181, 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 189, 189, 190, 191, 192, 192, 193, 193, 194, 195, 195, 196, 197, 197, 198, 199, 199, 200, 201, 201, 202, 203, 203, 204, 204, 205, 206, 206, 207, 208, 208, 209, 209, 210, 211, 211, 212, 212, 213, 214, 214, 215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 221, 221, 222, 222, 223, 224, 224, 225, 225, 226, 226, 227, 227, 228, 229, 229, 230, 230, 231, 231, 232, 232, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255 }; static INLINE int ss_isqrt(int x) { int y, e; if(x >= (SS_BLOCKSIZE * SS_BLOCKSIZE)) { return SS_BLOCKSIZE; } e = (x & 0xffff0000) ? ((x & 0xff000000) ? 24 + lg_table[(x >> 24) & 0xff] : 16 + lg_table[(x >> 16) & 0xff]) : ((x & 0x0000ff00) ? 8 + lg_table[(x >> 8) & 0xff] : 0 + lg_table[(x >> 0) & 0xff]); if(e >= 16) { y = sqq_table[x >> ((e - 6) - (e & 1))] << ((e >> 1) - 7); if(e >= 24) { y = (y + 1 + x / y) >> 1; } y = (y + 1 + x / y) >> 1; } else if(e >= 8) { y = (sqq_table[x >> ((e - 6) - (e & 1))] >> (7 - (e >> 1))) + 1; } else { return sqq_table[x] >> 4; } return (x < (y * y)) ? y - 1 : y; } #endif /* SS_BLOCKSIZE != 0 */ /*---------------------------------------------------------------------------*/ /* Compares two suffixes. */ static INLINE int ss_compare(const unsigned char *T, const int *p1, const int *p2, int depth) { const unsigned char *U1, *U2, *U1n, *U2n; for(U1 = T + depth + *p1, U2 = T + depth + *p2, U1n = T + *(p1 + 1) + 2, U2n = T + *(p2 + 1) + 2; (U1 < U1n) && (U2 < U2n) && (*U1 == *U2); ++U1, ++U2) { } return U1 < U1n ? (U2 < U2n ? *U1 - *U2 : 1) : (U2 < U2n ? -1 : 0); } /*---------------------------------------------------------------------------*/ #if (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1) /* Insertionsort for small size groups */ static void ss_insertionsort(const unsigned char *T, const int *PA, int *first, int *last, int depth) { int *i, *j; int t; int r; for(i = last - 2; first <= i; --i) { for(t = *i, j = i + 1; 0 < (r = ss_compare(T, PA + t, PA + *j, depth));) { do { *(j - 1) = *j; } while((++j < last) && (*j < 0)); if(last <= j) { break; } } if(r == 0) { *j = ~*j; } *(j - 1) = t; } } #endif /* (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1) */ /*---------------------------------------------------------------------------*/ #if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) static INLINE void ss_fixdown(const unsigned char *Td, const int *PA, int *SA, int i, int size) { int j, k; int v; int c, d, e; for(v = SA[i], c = Td[PA[v]]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) { d = Td[PA[SA[k = j++]]]; if(d < (e = Td[PA[SA[j]]])) { k = j; d = e; } if(d <= c) { break; } } SA[i] = v; } /* Simple top-down heapsort. */ static void ss_heapsort(const unsigned char *Td, const int *PA, int *SA, int size) { int i, m; int t; m = size; if((size % 2) == 0) { m--; if(Td[PA[SA[m / 2]]] < Td[PA[SA[m]]]) { SWAP(SA[m], SA[m / 2]); } } for(i = m / 2 - 1; 0 <= i; --i) { ss_fixdown(Td, PA, SA, i, m); } if((size % 2) == 0) { SWAP(SA[0], SA[m]); ss_fixdown(Td, PA, SA, 0, m); } for(i = m - 1; 0 < i; --i) { t = SA[0], SA[0] = SA[i]; ss_fixdown(Td, PA, SA, 0, i); SA[i] = t; } } /*---------------------------------------------------------------------------*/ /* Returns the median of three elements. */ static INLINE int * ss_median3(const unsigned char *Td, const int *PA, int *v1, int *v2, int *v3) { int *t; if(Td[PA[*v1]] > Td[PA[*v2]]) { SWAP(v1, v2); } if(Td[PA[*v2]] > Td[PA[*v3]]) { if(Td[PA[*v1]] > Td[PA[*v3]]) { return v1; } else { return v3; } } return v2; } /* Returns the median of five elements. */ static INLINE int * ss_median5(const unsigned char *Td, const int *PA, int *v1, int *v2, int *v3, int *v4, int *v5) { int *t; if(Td[PA[*v2]] > Td[PA[*v3]]) { SWAP(v2, v3); } if(Td[PA[*v4]] > Td[PA[*v5]]) { SWAP(v4, v5); } if(Td[PA[*v2]] > Td[PA[*v4]]) { SWAP(v2, v4); SWAP(v3, v5); } if(Td[PA[*v1]] > Td[PA[*v3]]) { SWAP(v1, v3); } if(Td[PA[*v1]] > Td[PA[*v4]]) { SWAP(v1, v4); SWAP(v3, v5); } if(Td[PA[*v3]] > Td[PA[*v4]]) { return v4; } return v3; } /* Returns the pivot element. */ static INLINE int * ss_pivot(const unsigned char *Td, const int *PA, int *first, int *last) { int *middle; int t; t = last - first; middle = first + t / 2; if(t <= 512) { if(t <= 32) { return ss_median3(Td, PA, first, middle, last - 1); } else { t >>= 2; return ss_median5(Td, PA, first, first + t, middle, last - 1 - t, last - 1); } } t >>= 3; first = ss_median3(Td, PA, first, first + t, first + (t << 1)); middle = ss_median3(Td, PA, middle - t, middle, middle + t); last = ss_median3(Td, PA, last - 1 - (t << 1), last - 1 - t, last - 1); return ss_median3(Td, PA, first, middle, last); } /*---------------------------------------------------------------------------*/ /* Binary partition for substrings. */ static INLINE int * ss_partition(const int *PA, int *first, int *last, int depth) { int *a, *b; int t; for(a = first - 1, b = last;;) { for(; (++a < b) && ((PA[*a] + depth) >= (PA[*a + 1] + 1));) { *a = ~*a; } for(; (a < --b) && ((PA[*b] + depth) < (PA[*b + 1] + 1));) { } if(b <= a) { break; } t = ~*b; *b = *a; *a = t; } if(first < a) { *first = ~*first; } return a; } /* Multikey introsort for medium size groups. */ static void ss_mintrosort(const unsigned char *T, const int *PA, int *first, int *last, int depth) { #define STACK_SIZE SS_MISORT_STACKSIZE struct { int *a, *b, c; int d; } stack[STACK_SIZE]; const unsigned char *Td; int *a, *b, *c, *d, *e, *f; int s, t; int ssize; int limit; int v, x = 0; for(ssize = 0, limit = ss_ilg(last - first);;) { if((last - first) <= SS_INSERTIONSORT_THRESHOLD) { #if 1 < SS_INSERTIONSORT_THRESHOLD if(1 < (last - first)) { ss_insertionsort(T, PA, first, last, depth); } #endif STACK_POP(first, last, depth, limit); continue; } Td = T + depth; if(limit-- == 0) { ss_heapsort(Td, PA, first, last - first); } if(limit < 0) { for(a = first + 1, v = Td[PA[*first]]; a < last; ++a) { if((x = Td[PA[*a]]) != v) { if(1 < (a - first)) { break; } v = x; first = a; } } if(Td[PA[*first] - 1] < v) { first = ss_partition(PA, first, a, depth); } if((a - first) <= (last - a)) { if(1 < (a - first)) { STACK_PUSH(a, last, depth, -1); last = a, depth += 1, limit = ss_ilg(a - first); } else { first = a, limit = -1; } } else { if(1 < (last - a)) { STACK_PUSH(first, a, depth + 1, ss_ilg(a - first)); first = a, limit = -1; } else { last = a, depth += 1, limit = ss_ilg(a - first); } } continue; } /* choose pivot */ a = ss_pivot(Td, PA, first, last); v = Td[PA[*a]]; SWAP(*first, *a); /* partition */ for(b = first; (++b < last) && ((x = Td[PA[*b]]) == v);) { } if(((a = b) < last) && (x < v)) { for(; (++b < last) && ((x = Td[PA[*b]]) <= v);) { if(x == v) { SWAP(*b, *a); ++a; } } } for(c = last; (b < --c) && ((x = Td[PA[*c]]) == v);) { } if((b < (d = c)) && (x > v)) { for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) { if(x == v) { SWAP(*c, *d); --d; } } } for(; b < c;) { SWAP(*b, *c); for(; (++b < c) && ((x = Td[PA[*b]]) <= v);) { if(x == v) { SWAP(*b, *a); ++a; } } for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) { if(x == v) { SWAP(*c, *d); --d; } } } if(a <= d) { c = b - 1; if((s = a - first) > (t = b - a)) { s = t; } for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); } if((s = d - c) > (t = last - d - 1)) { s = t; } for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); } a = first + (b - a), c = last - (d - c); b = (v <= Td[PA[*a] - 1]) ? a : ss_partition(PA, a, c, depth); if((a - first) <= (last - c)) { if((last - c) <= (c - b)) { STACK_PUSH(b, c, depth + 1, ss_ilg(c - b)); STACK_PUSH(c, last, depth, limit); last = a; } else if((a - first) <= (c - b)) { STACK_PUSH(c, last, depth, limit); STACK_PUSH(b, c, depth + 1, ss_ilg(c - b)); last = a; } else { STACK_PUSH(c, last, depth, limit); STACK_PUSH(first, a, depth, limit); first = b, last = c, depth += 1, limit = ss_ilg(c - b); } } else { if((a - first) <= (c - b)) { STACK_PUSH(b, c, depth + 1, ss_ilg(c - b)); STACK_PUSH(first, a, depth, limit); first = c; } else if((last - c) <= (c - b)) { STACK_PUSH(first, a, depth, limit); STACK_PUSH(b, c, depth + 1, ss_ilg(c - b)); first = c; } else { STACK_PUSH(first, a, depth, limit); STACK_PUSH(c, last, depth, limit); first = b, last = c, depth += 1, limit = ss_ilg(c - b); } } } else { limit += 1; if(Td[PA[*first] - 1] < v) { first = ss_partition(PA, first, last, depth); limit = ss_ilg(last - first); } depth += 1; } } #undef STACK_SIZE } #endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */ /*---------------------------------------------------------------------------*/ #if SS_BLOCKSIZE != 0 static INLINE void ss_blockswap(int *a, int *b, int n) { int t; for(; 0 < n; --n, ++a, ++b) { t = *a, *a = *b, *b = t; } } static INLINE void ss_rotate(int *first, int *middle, int *last) { int *a, *b, t; int l, r; l = middle - first, r = last - middle; for(; (0 < l) && (0 < r);) { if(l == r) { ss_blockswap(first, middle, l); break; } if(l < r) { a = last - 1, b = middle - 1; t = *a; do { *a-- = *b, *b-- = *a; if(b < first) { *a = t; last = a; if((r -= l + 1) <= l) { break; } a -= 1, b = middle - 1; t = *a; } } while(1); } else { a = first, b = middle; t = *a; do { *a++ = *b, *b++ = *a; if(last <= b) { *a = t; first = a + 1; if((l -= r + 1) <= r) { break; } a += 1, b = middle; t = *a; } } while(1); } } } /*---------------------------------------------------------------------------*/ static void ss_inplacemerge(const unsigned char *T, const int *PA, int *first, int *middle, int *last, int depth) { const int *p; int *a, *b; int len, half; int q, r; int x; for(;;) { if(*(last - 1) < 0) { x = 1; p = PA + ~*(last - 1); } else { x = 0; p = PA + *(last - 1); } for(a = first, len = middle - first, half = len >> 1, r = -1; 0 < len; len = half, half >>= 1) { b = a + half; q = ss_compare(T, PA + ((0 <= *b) ? *b : ~*b), p, depth); if(q < 0) { a = b + 1; half -= (len & 1) ^ 1; } else { r = q; } } if(a < middle) { if(r == 0) { *a = ~*a; } ss_rotate(a, middle, last); last -= middle - a; middle = a; if(first == middle) { break; } } --last; if(x != 0) { while(*--last < 0) { } } if(middle == last) { break; } } } /*---------------------------------------------------------------------------*/ /* Merge-forward with internal buffer. */ static void ss_mergeforward(const unsigned char *T, const int *PA, int *first, int *middle, int *last, int *buf, int depth) { int *a, *b, *c, *bufend; int t; int r; bufend = buf + (middle - first) - 1; ss_blockswap(buf, first, middle - first); for(t = *(a = first), b = buf, c = middle;;) { r = ss_compare(T, PA + *b, PA + *c, depth); if(r < 0) { do { *a++ = *b; if(bufend <= b) { *bufend = t; return; } *b++ = *a; } while(*b < 0); } else if(r > 0) { do { *a++ = *c, *c++ = *a; if(last <= c) { while(b < bufend) { *a++ = *b, *b++ = *a; } *a = *b, *b = t; return; } } while(*c < 0); } else { *c = ~*c; do { *a++ = *b; if(bufend <= b) { *bufend = t; return; } *b++ = *a; } while(*b < 0); do { *a++ = *c, *c++ = *a; if(last <= c) { while(b < bufend) { *a++ = *b, *b++ = *a; } *a = *b, *b = t; return; } } while(*c < 0); } } } /* Merge-backward with internal buffer. */ static void ss_mergebackward(const unsigned char *T, const int *PA, int *first, int *middle, int *last, int *buf, int depth) { const int *p1, *p2; int *a, *b, *c, *bufend; int t; int r; int x; bufend = buf + (last - middle) - 1; ss_blockswap(buf, middle, last - middle); x = 0; if(*bufend < 0) { p1 = PA + ~*bufend; x |= 1; } else { p1 = PA + *bufend; } if(*(middle - 1) < 0) { p2 = PA + ~*(middle - 1); x |= 2; } else { p2 = PA + *(middle - 1); } for(t = *(a = last - 1), b = bufend, c = middle - 1;;) { r = ss_compare(T, p1, p2, depth); if(0 < r) { if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; } *a-- = *b; if(b <= buf) { *buf = t; break; } *b-- = *a; if(*b < 0) { p1 = PA + ~*b; x |= 1; } else { p1 = PA + *b; } } else if(r < 0) { if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; } *a-- = *c, *c-- = *a; if(c < first) { while(buf < b) { *a-- = *b, *b-- = *a; } *a = *b, *b = t; break; } if(*c < 0) { p2 = PA + ~*c; x |= 2; } else { p2 = PA + *c; } } else { if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; } *a-- = ~*b; if(b <= buf) { *buf = t; break; } *b-- = *a; if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; } *a-- = *c, *c-- = *a; if(c < first) { while(buf < b) { *a-- = *b, *b-- = *a; } *a = *b, *b = t; break; } if(*b < 0) { p1 = PA + ~*b; x |= 1; } else { p1 = PA + *b; } if(*c < 0) { p2 = PA + ~*c; x |= 2; } else { p2 = PA + *c; } } } } /* D&C based merge. */ static void ss_swapmerge(const unsigned char *T, const int *PA, int *first, int *middle, int *last, int *buf, int bufsize, int depth) { #define STACK_SIZE SS_SMERGE_STACKSIZE #define GETIDX(a) ((0 <= (a)) ? (a) : (~(a))) #define MERGE_CHECK(a, b, c)\ do {\ if(((c) & 1) ||\ (((c) & 2) && (ss_compare(T, PA + GETIDX(*((a) - 1)), PA + *(a), depth) == 0))) {\ *(a) = ~*(a);\ }\ if(((c) & 4) && ((ss_compare(T, PA + GETIDX(*((b) - 1)), PA + *(b), depth) == 0))) {\ *(b) = ~*(b);\ }\ } while(0) struct { int *a, *b, *c; int d; } stack[STACK_SIZE]; int *l, *r, *lm, *rm; int m, len, half; int ssize; int check, next; for(check = 0, ssize = 0;;) { if((last - middle) <= bufsize) { if((first < middle) && (middle < last)) { ss_mergebackward(T, PA, first, middle, last, buf, depth); } MERGE_CHECK(first, last, check); STACK_POP(first, middle, last, check); continue; } if((middle - first) <= bufsize) { if(first < middle) { ss_mergeforward(T, PA, first, middle, last, buf, depth); } MERGE_CHECK(first, last, check); STACK_POP(first, middle, last, check); continue; } for(m = 0, len = MIN(middle - first, last - middle), half = len >> 1; 0 < len; len = half, half >>= 1) { if(ss_compare(T, PA + GETIDX(*(middle + m + half)), PA + GETIDX(*(middle - m - half - 1)), depth) < 0) { m += half + 1; half -= (len & 1) ^ 1; } } if(0 < m) { lm = middle - m, rm = middle + m; ss_blockswap(lm, middle, m); l = r = middle, next = 0; if(rm < last) { if(*rm < 0) { *rm = ~*rm; if(first < lm) { for(; *--l < 0;) { } next |= 4; } next |= 1; } else if(first < lm) { for(; *r < 0; ++r) { } next |= 2; } } if((l - first) <= (last - r)) { STACK_PUSH(r, rm, last, (next & 3) | (check & 4)); middle = lm, last = l, check = (check & 3) | (next & 4); } else { if((next & 2) && (r == middle)) { next ^= 6; } STACK_PUSH(first, lm, l, (check & 3) | (next & 4)); first = r, middle = rm, check = (next & 3) | (check & 4); } } else { if(ss_compare(T, PA + GETIDX(*(middle - 1)), PA + *middle, depth) == 0) { *middle = ~*middle; } MERGE_CHECK(first, last, check); STACK_POP(first, middle, last, check); } } #undef STACK_SIZE } #endif /* SS_BLOCKSIZE != 0 */ /*---------------------------------------------------------------------------*/ /* Substring sort */ static void sssort(const unsigned char *T, const int *PA, int *first, int *last, int *buf, int bufsize, int depth, int n, int lastsuffix) { int *a; #if SS_BLOCKSIZE != 0 int *b, *middle, *curbuf; int j, k, curbufsize, limit; #endif int i; if(lastsuffix != 0) { ++first; } #if SS_BLOCKSIZE == 0 ss_mintrosort(T, PA, first, last, depth); #else if((bufsize < SS_BLOCKSIZE) && (bufsize < (last - first)) && (bufsize < (limit = ss_isqrt(last - first)))) { if(SS_BLOCKSIZE < limit) { limit = SS_BLOCKSIZE; } buf = middle = last - limit, bufsize = limit; } else { middle = last, limit = 0; } for(a = first, i = 0; SS_BLOCKSIZE < (middle - a); a += SS_BLOCKSIZE, ++i) { #if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE ss_mintrosort(T, PA, a, a + SS_BLOCKSIZE, depth); #elif 1 < SS_BLOCKSIZE ss_insertionsort(T, PA, a, a + SS_BLOCKSIZE, depth); #endif curbufsize = last - (a + SS_BLOCKSIZE); curbuf = a + SS_BLOCKSIZE; if(curbufsize <= bufsize) { curbufsize = bufsize, curbuf = buf; } for(b = a, k = SS_BLOCKSIZE, j = i; j & 1; b -= k, k <<= 1, j >>= 1) { ss_swapmerge(T, PA, b - k, b, b + k, curbuf, curbufsize, depth); } } #if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE ss_mintrosort(T, PA, a, middle, depth); #elif 1 < SS_BLOCKSIZE ss_insertionsort(T, PA, a, middle, depth); #endif for(k = SS_BLOCKSIZE; i != 0; k <<= 1, i >>= 1) { if(i & 1) { ss_swapmerge(T, PA, a - k, a, middle, buf, bufsize, depth); a -= k; } } if(limit != 0) { #if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE ss_mintrosort(T, PA, middle, last, depth); #elif 1 < SS_BLOCKSIZE ss_insertionsort(T, PA, middle, last, depth); #endif ss_inplacemerge(T, PA, first, middle, last, depth); } #endif if(lastsuffix != 0) { /* Insert last type B* suffix. */ int PAi[2]; PAi[0] = PA[*(first - 1)], PAi[1] = n - 2; for(a = first, i = *(first - 1); (a < last) && ((*a < 0) || (0 < ss_compare(T, &(PAi[0]), PA + *a, depth))); ++a) { *(a - 1) = *a; } *(a - 1) = i; } } /*---------------------------------------------------------------------------*/ static INLINE int tr_ilg(int n) { return (n & 0xffff0000) ? ((n & 0xff000000) ? 24 + lg_table[(n >> 24) & 0xff] : 16 + lg_table[(n >> 16) & 0xff]) : ((n & 0x0000ff00) ? 8 + lg_table[(n >> 8) & 0xff] : 0 + lg_table[(n >> 0) & 0xff]); } /*---------------------------------------------------------------------------*/ /* Simple insertionsort for small size groups. */ static void tr_insertionsort(const int *ISAd, int *first, int *last) { int *a, *b; int t, r; for(a = first + 1; a < last; ++a) { for(t = *a, b = a - 1; 0 > (r = ISAd[t] - ISAd[*b]);) { do { *(b + 1) = *b; } while((first <= --b) && (*b < 0)); if(b < first) { break; } } if(r == 0) { *b = ~*b; } *(b + 1) = t; } } /*---------------------------------------------------------------------------*/ static INLINE void tr_fixdown(const int *ISAd, int *SA, int i, int size) { int j, k; int v; int c, d, e; for(v = SA[i], c = ISAd[v]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) { d = ISAd[SA[k = j++]]; if(d < (e = ISAd[SA[j]])) { k = j; d = e; } if(d <= c) { break; } } SA[i] = v; } /* Simple top-down heapsort. */ static void tr_heapsort(const int *ISAd, int *SA, int size) { int i, m; int t; m = size; if((size % 2) == 0) { m--; if(ISAd[SA[m / 2]] < ISAd[SA[m]]) { SWAP(SA[m], SA[m / 2]); } } for(i = m / 2 - 1; 0 <= i; --i) { tr_fixdown(ISAd, SA, i, m); } if((size % 2) == 0) { SWAP(SA[0], SA[m]); tr_fixdown(ISAd, SA, 0, m); } for(i = m - 1; 0 < i; --i) { t = SA[0], SA[0] = SA[i]; tr_fixdown(ISAd, SA, 0, i); SA[i] = t; } } /*---------------------------------------------------------------------------*/ /* Returns the median of three elements. */ static INLINE int * tr_median3(const int *ISAd, int *v1, int *v2, int *v3) { int *t; if(ISAd[*v1] > ISAd[*v2]) { SWAP(v1, v2); } if(ISAd[*v2] > ISAd[*v3]) { if(ISAd[*v1] > ISAd[*v3]) { return v1; } else { return v3; } } return v2; } /* Returns the median of five elements. */ static INLINE int * tr_median5(const int *ISAd, int *v1, int *v2, int *v3, int *v4, int *v5) { int *t; if(ISAd[*v2] > ISAd[*v3]) { SWAP(v2, v3); } if(ISAd[*v4] > ISAd[*v5]) { SWAP(v4, v5); } if(ISAd[*v2] > ISAd[*v4]) { SWAP(v2, v4); SWAP(v3, v5); } if(ISAd[*v1] > ISAd[*v3]) { SWAP(v1, v3); } if(ISAd[*v1] > ISAd[*v4]) { SWAP(v1, v4); SWAP(v3, v5); } if(ISAd[*v3] > ISAd[*v4]) { return v4; } return v3; } /* Returns the pivot element. */ static INLINE int * tr_pivot(const int *ISAd, int *first, int *last) { int *middle; int t; t = last - first; middle = first + t / 2; if(t <= 512) { if(t <= 32) { return tr_median3(ISAd, first, middle, last - 1); } else { t >>= 2; return tr_median5(ISAd, first, first + t, middle, last - 1 - t, last - 1); } } t >>= 3; first = tr_median3(ISAd, first, first + t, first + (t << 1)); middle = tr_median3(ISAd, middle - t, middle, middle + t); last = tr_median3(ISAd, last - 1 - (t << 1), last - 1 - t, last - 1); return tr_median3(ISAd, first, middle, last); } /*---------------------------------------------------------------------------*/ typedef struct _trbudget_t trbudget_t; struct _trbudget_t { int chance; int remain; int incval; int count; }; static INLINE void trbudget_init(trbudget_t *budget, int chance, int incval) { budget->chance = chance; budget->remain = budget->incval = incval; } static INLINE int trbudget_check(trbudget_t *budget, int size) { if(size <= budget->remain) { budget->remain -= size; return 1; } if(budget->chance == 0) { budget->count += size; return 0; } budget->remain += budget->incval - size; budget->chance -= 1; return 1; } /*---------------------------------------------------------------------------*/ static INLINE void tr_partition(const int *ISAd, int *first, int *middle, int *last, int **pa, int **pb, int v) { int *a, *b, *c, *d, *e, *f; int t, s; int x = 0; for(b = middle - 1; (++b < last) && ((x = ISAd[*b]) == v);) { } if(((a = b) < last) && (x < v)) { for(; (++b < last) && ((x = ISAd[*b]) <= v);) { if(x == v) { SWAP(*b, *a); ++a; } } } for(c = last; (b < --c) && ((x = ISAd[*c]) == v);) { } if((b < (d = c)) && (x > v)) { for(; (b < --c) && ((x = ISAd[*c]) >= v);) { if(x == v) { SWAP(*c, *d); --d; } } } for(; b < c;) { SWAP(*b, *c); for(; (++b < c) && ((x = ISAd[*b]) <= v);) { if(x == v) { SWAP(*b, *a); ++a; } } for(; (b < --c) && ((x = ISAd[*c]) >= v);) { if(x == v) { SWAP(*c, *d); --d; } } } if(a <= d) { c = b - 1; if((s = a - first) > (t = b - a)) { s = t; } for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); } if((s = d - c) > (t = last - d - 1)) { s = t; } for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); } first += (b - a), last -= (d - c); } *pa = first, *pb = last; } static void tr_copy(int *ISA, const int *SA, int *first, int *a, int *b, int *last, int depth) { /* sort suffixes of middle partition by using sorted order of suffixes of left and right partition. */ int *c, *d, *e; int s, v; v = b - SA - 1; for(c = first, d = a - 1; c <= d; ++c) { if((0 <= (s = *c - depth)) && (ISA[s] == v)) { *++d = s; ISA[s] = d - SA; } } for(c = last - 1, e = d + 1, d = b; e < d; --c) { if((0 <= (s = *c - depth)) && (ISA[s] == v)) { *--d = s; ISA[s] = d - SA; } } } static void tr_partialcopy(int *ISA, const int *SA, int *first, int *a, int *b, int *last, int depth) { int *c, *d, *e; int s, v; int rank, lastrank, newrank = -1; v = b - SA - 1; lastrank = -1; for(c = first, d = a - 1; c <= d; ++c) { if((0 <= (s = *c - depth)) && (ISA[s] == v)) { *++d = s; rank = ISA[s + depth]; if(lastrank != rank) { lastrank = rank; newrank = d - SA; } ISA[s] = newrank; } } lastrank = -1; for(e = d; first <= e; --e) { rank = ISA[*e]; if(lastrank != rank) { lastrank = rank; newrank = e - SA; } if(newrank != rank) { ISA[*e] = newrank; } } lastrank = -1; for(c = last - 1, e = d + 1, d = b; e < d; --c) { if((0 <= (s = *c - depth)) && (ISA[s] == v)) { *--d = s; rank = ISA[s + depth]; if(lastrank != rank) { lastrank = rank; newrank = d - SA; } ISA[s] = newrank; } } } static void tr_introsort(int *ISA, const int *ISAd, int *SA, int *first, int *last, trbudget_t *budget) { #define STACK_SIZE TR_STACKSIZE struct { const int *a; int *b, *c; int d, e; }stack[STACK_SIZE]; int *a, *b, *c; int t; int v, x = 0; int incr = ISAd - ISA; int limit, next; int ssize, trlink = -1; for(ssize = 0, limit = tr_ilg(last - first);;) { if(limit < 0) { if(limit == -1) { /* tandem repeat partition */ tr_partition(ISAd - incr, first, first, last, &a, &b, last - SA - 1); /* update ranks */ if(a < last) { for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; } } if(b < last) { for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; } } /* push */ if(1 < (b - a)) { STACK_PUSH5(NULL, a, b, 0, 0); STACK_PUSH5(ISAd - incr, first, last, -2, trlink); trlink = ssize - 2; } if((a - first) <= (last - b)) { if(1 < (a - first)) { STACK_PUSH5(ISAd, b, last, tr_ilg(last - b), trlink); last = a, limit = tr_ilg(a - first); } else if(1 < (last - b)) { first = b, limit = tr_ilg(last - b); } else { STACK_POP5(ISAd, first, last, limit, trlink); } } else { if(1 < (last - b)) { STACK_PUSH5(ISAd, first, a, tr_ilg(a - first), trlink); first = b, limit = tr_ilg(last - b); } else if(1 < (a - first)) { last = a, limit = tr_ilg(a - first); } else { STACK_POP5(ISAd, first, last, limit, trlink); } } } else if(limit == -2) { /* tandem repeat copy */ a = stack[--ssize].b, b = stack[ssize].c; if(stack[ssize].d == 0) { tr_copy(ISA, SA, first, a, b, last, ISAd - ISA); } else { if(0 <= trlink) { stack[trlink].d = -1; } tr_partialcopy(ISA, SA, first, a, b, last, ISAd - ISA); } STACK_POP5(ISAd, first, last, limit, trlink); } else { /* sorted partition */ if(0 <= *first) { a = first; do { ISA[*a] = a - SA; } while((++a < last) && (0 <= *a)); first = a; } if(first < last) { a = first; do { *a = ~*a; } while(*++a < 0); next = (ISA[*a] != ISAd[*a]) ? tr_ilg(a - first + 1) : -1; if(++a < last) { for(b = first, v = a - SA - 1; b < a; ++b) { ISA[*b] = v; } } /* push */ if(trbudget_check(budget, a - first)) { if((a - first) <= (last - a)) { STACK_PUSH5(ISAd, a, last, -3, trlink); ISAd += incr, last = a, limit = next; } else { if(1 < (last - a)) { STACK_PUSH5(ISAd + incr, first, a, next, trlink); first = a, limit = -3; } else { ISAd += incr, last = a, limit = next; } } } else { if(0 <= trlink) { stack[trlink].d = -1; } if(1 < (last - a)) { first = a, limit = -3; } else { STACK_POP5(ISAd, first, last, limit, trlink); } } } else { STACK_POP5(ISAd, first, last, limit, trlink); } } continue; } if((last - first) <= TR_INSERTIONSORT_THRESHOLD) { tr_insertionsort(ISAd, first, last); limit = -3; continue; } if(limit-- == 0) { tr_heapsort(ISAd, first, last - first); for(a = last - 1; first < a; a = b) { for(x = ISAd[*a], b = a - 1; (first <= b) && (ISAd[*b] == x); --b) { *b = ~*b; } } limit = -3; continue; } /* choose pivot */ a = tr_pivot(ISAd, first, last); SWAP(*first, *a); v = ISAd[*first]; /* partition */ tr_partition(ISAd, first, first + 1, last, &a, &b, v); if((last - first) != (b - a)) { next = (ISA[*a] != v) ? tr_ilg(b - a) : -1; /* update ranks */ for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; } if(b < last) { for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; } } /* push */ if((1 < (b - a)) && (trbudget_check(budget, b - a))) { if((a - first) <= (last - b)) { if((last - b) <= (b - a)) { if(1 < (a - first)) { STACK_PUSH5(ISAd + incr, a, b, next, trlink); STACK_PUSH5(ISAd, b, last, limit, trlink); last = a; } else if(1 < (last - b)) { STACK_PUSH5(ISAd + incr, a, b, next, trlink); first = b; } else { ISAd += incr, first = a, last = b, limit = next; } } else if((a - first) <= (b - a)) { if(1 < (a - first)) { STACK_PUSH5(ISAd, b, last, limit, trlink); STACK_PUSH5(ISAd + incr, a, b, next, trlink); last = a; } else { STACK_PUSH5(ISAd, b, last, limit, trlink); ISAd += incr, first = a, last = b, limit = next; } } else { STACK_PUSH5(ISAd, b, last, limit, trlink); STACK_PUSH5(ISAd, first, a, limit, trlink); ISAd += incr, first = a, last = b, limit = next; } } else { if((a - first) <= (b - a)) { if(1 < (last - b)) { STACK_PUSH5(ISAd + incr, a, b, next, trlink); STACK_PUSH5(ISAd, first, a, limit, trlink); first = b; } else if(1 < (a - first)) { STACK_PUSH5(ISAd + incr, a, b, next, trlink); last = a; } else { ISAd += incr, first = a, last = b, limit = next; } } else if((last - b) <= (b - a)) { if(1 < (last - b)) { STACK_PUSH5(ISAd, first, a, limit, trlink); STACK_PUSH5(ISAd + incr, a, b, next, trlink); first = b; } else { STACK_PUSH5(ISAd, first, a, limit, trlink); ISAd += incr, first = a, last = b, limit = next; } } else { STACK_PUSH5(ISAd, first, a, limit, trlink); STACK_PUSH5(ISAd, b, last, limit, trlink); ISAd += incr, first = a, last = b, limit = next; } } } else { if((1 < (b - a)) && (0 <= trlink)) { stack[trlink].d = -1; } if((a - first) <= (last - b)) { if(1 < (a - first)) { STACK_PUSH5(ISAd, b, last, limit, trlink); last = a; } else if(1 < (last - b)) { first = b; } else { STACK_POP5(ISAd, first, last, limit, trlink); } } else { if(1 < (last - b)) { STACK_PUSH5(ISAd, first, a, limit, trlink); first = b; } else if(1 < (a - first)) { last = a; } else { STACK_POP5(ISAd, first, last, limit, trlink); } } } } else { if(trbudget_check(budget, last - first)) { limit = tr_ilg(last - first), ISAd += incr; } else { if(0 <= trlink) { stack[trlink].d = -1; } STACK_POP5(ISAd, first, last, limit, trlink); } } } #undef STACK_SIZE } /*---------------------------------------------------------------------------*/ /* Tandem repeat sort */ static void trsort(int *ISA, int *SA, int n, int depth) { int *ISAd; int *first, *last; trbudget_t budget; int t, skip, unsorted; trbudget_init(&budget, tr_ilg(n) * 2 / 3, n); /* trbudget_init(&budget, tr_ilg(n) * 3 / 4, n); */ for(ISAd = ISA + depth; -n < *SA; ISAd += ISAd - ISA) { first = SA; skip = 0; unsorted = 0; do { if((t = *first) < 0) { first -= t; skip += t; } else { if(skip != 0) { *(first + skip) = skip; skip = 0; } last = SA + ISA[t] + 1; if(1 < (last - first)) { budget.count = 0; tr_introsort(ISA, ISAd, SA, first, last, &budget); if(budget.count != 0) { unsorted += budget.count; } else { skip = first - last; } } else if((last - first) == 1) { skip = -1; } first = last; } } while(first < (SA + n)); if(skip != 0) { *(first + skip) = skip; } if(unsorted == 0) { break; } } } /*---------------------------------------------------------------------------*/ /* Sorts suffixes of type B*. */ static int sort_typeBstar(const unsigned char *T, int *SA, int *bucket_A, int *bucket_B, int n, int openMP) { int *PAb, *ISAb, *buf; #ifdef LIBBSC_OPENMP int *curbuf; int l; #endif int i, j, k, t, m, bufsize; int c0, c1; #ifdef LIBBSC_OPENMP int d0, d1; #endif (void)openMP; /* Initialize bucket arrays. */ for(i = 0; i < BUCKET_A_SIZE; ++i) { bucket_A[i] = 0; } for(i = 0; i < BUCKET_B_SIZE; ++i) { bucket_B[i] = 0; } /* Count the number of occurrences of the first one or two characters of each type A, B and B* suffix. Moreover, store the beginning position of all type B* suffixes into the array SA. */ for(i = n - 1, m = n, c0 = T[n - 1]; 0 <= i;) { /* type A suffix. */ do { ++BUCKET_A(c1 = c0); } while((0 <= --i) && ((c0 = T[i]) >= c1)); if(0 <= i) { /* type B* suffix. */ ++BUCKET_BSTAR(c0, c1); SA[--m] = i; /* type B suffix. */ for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) { ++BUCKET_B(c0, c1); } } } m = n - m; /* note: A type B* suffix is lexicographically smaller than a type B suffix that begins with the same first two characters. */ /* Calculate the index of start/end point of each bucket. */ for(c0 = 0, i = 0, j = 0; c0 < ALPHABET_SIZE; ++c0) { t = i + BUCKET_A(c0); BUCKET_A(c0) = i + j; /* start point */ i = t + BUCKET_B(c0, c0); for(c1 = c0 + 1; c1 < ALPHABET_SIZE; ++c1) { j += BUCKET_BSTAR(c0, c1); BUCKET_BSTAR(c0, c1) = j; /* end point */ i += BUCKET_B(c0, c1); } } if(0 < m) { /* Sort the type B* suffixes by their first two characters. */ PAb = SA + n - m; ISAb = SA + m; for(i = m - 2; 0 <= i; --i) { t = PAb[i], c0 = T[t], c1 = T[t + 1]; SA[--BUCKET_BSTAR(c0, c1)] = i; } t = PAb[m - 1], c0 = T[t], c1 = T[t + 1]; SA[--BUCKET_BSTAR(c0, c1)] = m - 1; /* Sort the type B* substrings using sssort. */ #ifdef LIBBSC_OPENMP if (openMP) { buf = SA + m; c0 = ALPHABET_SIZE - 2, c1 = ALPHABET_SIZE - 1, j = m; #pragma omp parallel default(shared) private(bufsize, curbuf, k, l, d0, d1) { bufsize = (n - (2 * m)) / omp_get_num_threads(); curbuf = buf + omp_get_thread_num() * bufsize; k = 0; for(;;) { #pragma omp critical(sssort_lock) { if(0 < (l = j)) { d0 = c0, d1 = c1; do { k = BUCKET_BSTAR(d0, d1); if(--d1 <= d0) { d1 = ALPHABET_SIZE - 1; if(--d0 < 0) { break; } } } while(((l - k) <= 1) && (0 < (l = k))); c0 = d0, c1 = d1, j = k; } } if(l == 0) { break; } sssort(T, PAb, SA + k, SA + l, curbuf, bufsize, 2, n, *(SA + k) == (m - 1)); } } } else { buf = SA + m, bufsize = n - (2 * m); for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) { for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) { i = BUCKET_BSTAR(c0, c1); if(1 < (j - i)) { sssort(T, PAb, SA + i, SA + j, buf, bufsize, 2, n, *(SA + i) == (m - 1)); } } } } #else buf = SA + m, bufsize = n - (2 * m); for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) { for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) { i = BUCKET_BSTAR(c0, c1); if(1 < (j - i)) { sssort(T, PAb, SA + i, SA + j, buf, bufsize, 2, n, *(SA + i) == (m - 1)); } } } #endif /* Compute ranks of type B* substrings. */ for(i = m - 1; 0 <= i; --i) { if(0 <= SA[i]) { j = i; do { ISAb[SA[i]] = i; } while((0 <= --i) && (0 <= SA[i])); SA[i + 1] = i - j; if(i <= 0) { break; } } j = i; do { ISAb[SA[i] = ~SA[i]] = j; } while(SA[--i] < 0); ISAb[SA[i]] = j; } /* Construct the inverse suffix array of type B* suffixes using trsort. */ trsort(ISAb, SA, m, 1); /* Set the sorted order of tyoe B* suffixes. */ for(i = n - 1, j = m, c0 = T[n - 1]; 0 <= i;) { for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) >= c1); --i, c1 = c0) { } if(0 <= i) { t = i; for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) { } SA[ISAb[--j]] = ((t == 0) || (1 < (t - i))) ? t : ~t; } } /* Calculate the index of start/end point of each bucket. */ BUCKET_B(ALPHABET_SIZE - 1, ALPHABET_SIZE - 1) = n; /* end point */ for(c0 = ALPHABET_SIZE - 2, k = m - 1; 0 <= c0; --c0) { i = BUCKET_A(c0 + 1) - 1; for(c1 = ALPHABET_SIZE - 1; c0 < c1; --c1) { t = i - BUCKET_B(c0, c1); BUCKET_B(c0, c1) = i; /* end point */ /* Move all type B* suffixes to the correct position. */ for(i = t, j = BUCKET_BSTAR(c0, c1); j <= k; --i, --k) { SA[i] = SA[k]; } } BUCKET_BSTAR(c0, c0 + 1) = i - BUCKET_B(c0, c0) + 1; /* start point */ BUCKET_B(c0, c0) = i; /* end point */ } } return m; } /* Constructs the suffix array by using the sorted order of type B* suffixes. */ static void construct_SA(const unsigned char *T, int *SA, int *bucket_A, int *bucket_B, int n, int m) { int *i, *j, *k; int s; int c0, c1, c2; if(0 < m) { /* Construct the sorted order of type B suffixes by using the sorted order of type B* suffixes. */ for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) { /* Scan the suffix array from right to left. */ for(i = SA + BUCKET_BSTAR(c1, c1 + 1), j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1; i <= j; --j) { if(0 < (s = *j)) { assert(T[s] == c1); assert(((s + 1) < n) && (T[s] <= T[s + 1])); assert(T[s - 1] <= T[s]); *j = ~s; c0 = T[--s]; if((0 < s) && (T[s - 1] > c0)) { s = ~s; } if(c0 != c2) { if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; } k = SA + BUCKET_B(c2 = c0, c1); } assert(k < j); *k-- = s; } else { assert(((s == 0) && (T[s] == c1)) || (s < 0)); *j = ~s; } } } } /* Construct the suffix array by using the sorted order of type B suffixes. */ k = SA + BUCKET_A(c2 = T[n - 1]); *k++ = (T[n - 2] < c2) ? ~(n - 1) : (n - 1); /* Scan the suffix array from left to right. */ for(i = SA, j = SA + n; i < j; ++i) { if(0 < (s = *i)) { assert(T[s - 1] >= T[s]); c0 = T[--s]; if((s == 0) || (T[s - 1] < c0)) { s = ~s; } if(c0 != c2) { BUCKET_A(c2) = k - SA; k = SA + BUCKET_A(c2 = c0); } assert(i < k); *k++ = s; } else { assert(s < 0); *i = ~s; } } } /* Constructs the burrows-wheeler transformed string directly by using the sorted order of type B* suffixes. */ static int construct_BWT(const unsigned char *T, int *SA, int *bucket_A, int *bucket_B, int n, int m) { int *i, *j, *k, *orig; int s; int c0, c1, c2; if(0 < m) { /* Construct the sorted order of type B suffixes by using the sorted order of type B* suffixes. */ for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) { /* Scan the suffix array from right to left. */ for(i = SA + BUCKET_BSTAR(c1, c1 + 1), j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1; i <= j; --j) { if(0 < (s = *j)) { assert(T[s] == c1); assert(((s + 1) < n) && (T[s] <= T[s + 1])); assert(T[s - 1] <= T[s]); c0 = T[--s]; *j = ~((int)c0); if((0 < s) && (T[s - 1] > c0)) { s = ~s; } if(c0 != c2) { if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; } k = SA + BUCKET_B(c2 = c0, c1); } assert(k < j); *k-- = s; } else if(s != 0) { *j = ~s; #ifndef NDEBUG } else { assert(T[s] == c1); #endif } } } } /* Construct the BWTed string by using the sorted order of type B suffixes. */ k = SA + BUCKET_A(c2 = T[n - 1]); *k++ = (T[n - 2] < c2) ? ~((int)T[n - 2]) : (n - 1); /* Scan the suffix array from left to right. */ for(i = SA, j = SA + n, orig = SA; i < j; ++i) { if(0 < (s = *i)) { assert(T[s - 1] >= T[s]); c0 = T[--s]; *i = c0; if((0 < s) && (T[s - 1] < c0)) { s = ~((int)T[s - 1]); } if(c0 != c2) { BUCKET_A(c2) = k - SA; k = SA + BUCKET_A(c2 = c0); } assert(i < k); *k++ = s; } else if(s != 0) { *i = ~s; } else { orig = i; } } return orig - SA; } /* Constructs the burrows-wheeler transformed string directly by using the sorted order of type B* suffixes. */ static int construct_BWT_indexes(const unsigned char *T, int *SA, int *bucket_A, int *bucket_B, int n, int m, unsigned char * num_indexes, int * indexes) { int *i, *j, *k, *orig; int s; int c0, c1, c2; int mod = n / 8; { mod |= mod >> 1; mod |= mod >> 2; mod |= mod >> 4; mod |= mod >> 8; mod |= mod >> 16; mod >>= 1; *num_indexes = (unsigned char)((n - 1) / (mod + 1)); } if(0 < m) { /* Construct the sorted order of type B suffixes by using the sorted order of type B* suffixes. */ for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) { /* Scan the suffix array from right to left. */ for(i = SA + BUCKET_BSTAR(c1, c1 + 1), j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1; i <= j; --j) { if(0 < (s = *j)) { assert(T[s] == c1); assert(((s + 1) < n) && (T[s] <= T[s + 1])); assert(T[s - 1] <= T[s]); if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = j - SA; c0 = T[--s]; *j = ~((int)c0); if((0 < s) && (T[s - 1] > c0)) { s = ~s; } if(c0 != c2) { if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; } k = SA + BUCKET_B(c2 = c0, c1); } assert(k < j); *k-- = s; } else if(s != 0) { *j = ~s; #ifndef NDEBUG } else { assert(T[s] == c1); #endif } } } } /* Construct the BWTed string by using the sorted order of type B suffixes. */ k = SA + BUCKET_A(c2 = T[n - 1]); if (T[n - 2] < c2) { if (((n - 1) & mod) == 0) indexes[(n - 1) / (mod + 1) - 1] = k - SA; *k++ = ~((int)T[n - 2]); } else { *k++ = n - 1; } /* Scan the suffix array from left to right. */ for(i = SA, j = SA + n, orig = SA; i < j; ++i) { if(0 < (s = *i)) { assert(T[s - 1] >= T[s]); if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = i - SA; c0 = T[--s]; *i = c0; if(c0 != c2) { BUCKET_A(c2) = k - SA; k = SA + BUCKET_A(c2 = c0); } assert(i < k); if((0 < s) && (T[s - 1] < c0)) { if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = k - SA; *k++ = ~((int)T[s - 1]); } else *k++ = s; } else if(s != 0) { *i = ~s; } else { orig = i; } } return orig - SA; } /*---------------------------------------------------------------------------*/ /*- Function -*/ int divsufsort(const unsigned char *T, int *SA, int n, int openMP) { int *bucket_A, *bucket_B; int m; int err = 0; /* Check arguments. */ if((T == NULL) || (SA == NULL) || (n < 0)) { return -1; } else if(n == 0) { return 0; } else if(n == 1) { SA[0] = 0; return 0; } else if(n == 2) { m = (T[0] < T[1]); SA[m ^ 1] = 0, SA[m] = 1; return 0; } bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int)); bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int)); /* Suffixsort. */ if((bucket_A != NULL) && (bucket_B != NULL)) { m = sort_typeBstar(T, SA, bucket_A, bucket_B, n, openMP); construct_SA(T, SA, bucket_A, bucket_B, n, m); } else { err = -2; } free(bucket_B); free(bucket_A); return err; } int divbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP) { int *B; int *bucket_A, *bucket_B; int m, pidx, i; /* Check arguments. */ if((T == NULL) || (U == NULL) || (n < 0)) { return -1; } else if(n <= 1) { if(n == 1) { U[0] = T[0]; } return n; } if((B = A) == NULL) { B = (int *)malloc((size_t)(n + 1) * sizeof(int)); } bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int)); bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int)); /* Burrows-Wheeler Transform. */ if((B != NULL) && (bucket_A != NULL) && (bucket_B != NULL)) { m = sort_typeBstar(T, B, bucket_A, bucket_B, n, openMP); if (num_indexes == NULL || indexes == NULL) { pidx = construct_BWT(T, B, bucket_A, bucket_B, n, m); } else { pidx = construct_BWT_indexes(T, B, bucket_A, bucket_B, n, m, num_indexes, indexes); } /* Copy to output string. */ U[0] = T[n - 1]; for(i = 0; i < pidx; ++i) { U[i + 1] = (unsigned char)B[i]; } for(i += 1; i < n; ++i) { U[i] = (unsigned char)B[i]; } pidx += 1; } else { pidx = -2; } free(bucket_B); free(bucket_A); if(A == NULL) { free(B); } return pidx; } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/divsufsort.h ================================================ /* * divsufsort.h for libdivsufsort-lite * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved. * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #ifndef _DIVSUFSORT_H #define _DIVSUFSORT_H 1 #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ /*- Prototypes -*/ /** * Constructs the suffix array of a given string. * @param T [0..n-1] The input string. * @param SA [0..n-1] The output array of suffixes. * @param n The length of the given string. * @param openMP enables OpenMP optimization. * @return 0 if no error occurred, -1 or -2 otherwise. */ int divsufsort(const unsigned char *T, int *SA, int n, int openMP); /** * Constructs the burrows-wheeler transformed string of a given string. * @param T [0..n-1] The input string. * @param U [0..n-1] The output string. (can be T) * @param A [0..n-1] The temporary array. (can be NULL) * @param n The length of the given string. * @param num_indexes The length of secondary indexes array. (can be NULL) * @param indexes The secondary indexes array. (can be NULL) * @param openMP enables OpenMP optimization. * @return The primary index if no error occurred, -1 or -2 otherwise. */ int divbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP); #ifdef __cplusplus } /* extern "C" */ #endif /* __cplusplus */ #endif /* _DIVSUFSORT_H */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/entropy_common.c ================================================ /* Common functions of New Generation Entropy library Copyright (C) 2016, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c *************************************************************************** */ /* ************************************* * Dependencies ***************************************/ #include "mem.h" #include "error_private.h" /* ERR_*, ERROR */ #define FSE_STATIC_LINKING_ONLY /* FSE_MIN_TABLELOG */ #include "fse.h" #define HUF_STATIC_LINKING_ONLY /* HUF_TABLELOG_ABSOLUTEMAX */ #include "huf.h" /*=== Version ===*/ unsigned FSE_versionNumber(void) { return FSE_VERSION_NUMBER; } /*=== Error Management ===*/ unsigned FSE_isError(size_t code) { return ERR_isError(code); } const char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); } unsigned HUF_isError(size_t code) { return ERR_isError(code); } const char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); } /*-************************************************************** * FSE NCount encoding-decoding ****************************************************************/ size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr, const void* headerBuffer, size_t hbSize) { const BYTE* const istart = (const BYTE*) headerBuffer; const BYTE* const iend = istart + hbSize; const BYTE* ip = istart; int nbBits; int remaining; int threshold; U32 bitStream; int bitCount; unsigned charnum = 0; int previous0 = 0; if (hbSize < 4) return ERROR(srcSize_wrong); bitStream = MEM_readLE32(ip); nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG; /* extract tableLog */ if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge); bitStream >>= 4; bitCount = 4; *tableLogPtr = nbBits; remaining = (1<1) & (charnum<=*maxSVPtr)) { if (previous0) { unsigned n0 = charnum; while ((bitStream & 0xFFFF) == 0xFFFF) { n0 += 24; if (ip < iend-5) { ip += 2; bitStream = MEM_readLE32(ip) >> bitCount; } else { bitStream >>= 16; bitCount += 16; } } while ((bitStream & 3) == 3) { n0 += 3; bitStream >>= 2; bitCount += 2; } n0 += bitStream & 3; bitCount += 2; if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall); while (charnum < n0) normalizedCounter[charnum++] = 0; if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { ip += bitCount>>3; bitCount &= 7; bitStream = MEM_readLE32(ip) >> bitCount; } else { bitStream >>= 2; } } { int const max = (2*threshold-1) - remaining; int count; if ((bitStream & (threshold-1)) < (U32)max) { count = bitStream & (threshold-1); bitCount += nbBits-1; } else { count = bitStream & (2*threshold-1); if (count >= threshold) count -= max; bitCount += nbBits; } count--; /* extra accuracy */ remaining -= count < 0 ? -count : count; /* -1 means +1 */ normalizedCounter[charnum++] = (short)count; previous0 = !count; while (remaining < threshold) { nbBits--; threshold >>= 1; } if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { ip += bitCount>>3; bitCount &= 7; } else { bitCount -= (int)(8 * (iend - 4 - ip)); ip = iend - 4; } bitStream = MEM_readLE32(ip) >> (bitCount & 31); } } /* while ((remaining>1) & (charnum<=*maxSVPtr)) */ if (remaining != 1) return ERROR(corruption_detected); if (bitCount > 32) return ERROR(corruption_detected); *maxSVPtr = charnum-1; ip += (bitCount+7)>>3; return ip-istart; } /*! HUF_readStats() : Read compact Huffman tree, saved by HUF_writeCTable(). `huffWeight` is destination buffer. `rankStats` is assumed to be a table of at least HUF_TABLELOG_MAX U32. @return : size read from `src` , or an error Code . Note : Needed by HUF_readCTable() and HUF_readDTableX?() . */ size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr, const void* src, size_t srcSize) { U32 weightTotal; const BYTE* ip = (const BYTE*) src; size_t iSize; size_t oSize; if (!srcSize) return ERROR(srcSize_wrong); iSize = ip[0]; /* memset(huffWeight, 0, hwSize); *//* is not necessary, even though some analyzer complain ... */ if (iSize >= 128) { /* special header */ oSize = iSize - 127; iSize = ((oSize+1)/2); if (iSize+1 > srcSize) return ERROR(srcSize_wrong); if (oSize >= hwSize) return ERROR(corruption_detected); ip += 1; { U32 n; for (n=0; n> 4; huffWeight[n+1] = ip[n/2] & 15; } } } else { /* header compressed with FSE (normal case) */ FSE_DTable fseWorkspace[FSE_DTABLE_SIZE_U32(6)]; /* 6 is max possible tableLog for HUF header (maybe even 5, to be tested) */ if (iSize+1 > srcSize) return ERROR(srcSize_wrong); oSize = FSE_decompress_wksp(huffWeight, hwSize-1, ip+1, iSize, fseWorkspace, 6); /* max (hwSize-1) values decoded, as last one is implied */ if (FSE_isError(oSize)) return oSize; } /* collect weight stats */ memset(rankStats, 0, (HUF_TABLELOG_MAX + 1) * sizeof(U32)); weightTotal = 0; { U32 n; for (n=0; n= HUF_TABLELOG_MAX) return ERROR(corruption_detected); rankStats[huffWeight[n]]++; weightTotal += (1 << huffWeight[n]) >> 1; } } if (weightTotal == 0) return ERROR(corruption_detected); /* get last non-null symbol weight (implied, total must be 2^n) */ { U32 const tableLog = BIT_highbit32(weightTotal) + 1; if (tableLog > HUF_TABLELOG_MAX) return ERROR(corruption_detected); *tableLogPtr = tableLog; /* determine last weight */ { U32 const total = 1 << tableLog; U32 const rest = total - weightTotal; U32 const verif = 1 << BIT_highbit32(rest); U32 const lastWeight = BIT_highbit32(rest) + 1; if (verif != rest) return ERROR(corruption_detected); /* last value must be a clean power of 2 */ huffWeight[oSize] = (BYTE)lastWeight; rankStats[lastWeight]++; } } /* check tree construction validity */ if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected); /* by construction : at least 2 elts of rank 1, must be even */ /* results */ *nbSymbolsPtr = (U32)(oSize+1); return iSize+1; } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/error_private.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /* The purpose of this file is to have a single list of error strings embedded in binary */ #include "error_private.h" const char* ERR_getErrorString(ERR_enum code) { static const char* const notErrorCode = "Unspecified error code"; switch( code ) { case PREFIX(no_error): return "No error detected"; case PREFIX(GENERIC): return "Error (generic)"; case PREFIX(prefix_unknown): return "Unknown frame descriptor"; case PREFIX(version_unsupported): return "Version not supported"; case PREFIX(frameParameter_unsupported): return "Unsupported frame parameter"; case PREFIX(frameParameter_windowTooLarge): return "Frame requires too much memory for decoding"; case PREFIX(corruption_detected): return "Corrupted block detected"; case PREFIX(checksum_wrong): return "Restored data doesn't match checksum"; case PREFIX(parameter_unsupported): return "Unsupported parameter"; case PREFIX(parameter_outOfBound): return "Parameter is out of bound"; case PREFIX(init_missing): return "Context should be init first"; case PREFIX(memory_allocation): return "Allocation error : not enough memory"; case PREFIX(workSpace_tooSmall): return "workSpace buffer is not large enough"; case PREFIX(stage_wrong): return "Operation not authorized at current processing stage"; case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory : unsupported"; case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max Symbol Value : too large"; case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small"; case PREFIX(dictionary_corrupted): return "Dictionary is corrupted"; case PREFIX(dictionary_wrong): return "Dictionary mismatch"; case PREFIX(dictionaryCreation_failed): return "Cannot create Dictionary from provided samples"; case PREFIX(dstSize_tooSmall): return "Destination buffer is too small"; case PREFIX(srcSize_wrong): return "Src size is incorrect"; /* following error codes are not stable and may be removed or changed in a future version */ case PREFIX(frameIndex_tooLarge): return "Frame index is too large"; case PREFIX(seekableIO): return "An I/O error occurred when reading/seeking"; case PREFIX(maxCode): default: return notErrorCode; } } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/error_private.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /* Note : this module is expected to remain private, do not expose it */ #ifndef ERROR_H_MODULE #define ERROR_H_MODULE #if defined (__cplusplus) extern "C" { #endif /* **************************************** * Dependencies ******************************************/ #include /* size_t */ #include "zstd_errors.h" /* enum list */ /* **************************************** * Compiler-specific ******************************************/ #if defined(__GNUC__) # define ERR_STATIC static __attribute__((unused)) #elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) # define ERR_STATIC static inline #elif defined(_MSC_VER) # define ERR_STATIC static __inline #else # define ERR_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */ #endif /*-**************************************** * Customization (error_public.h) ******************************************/ typedef ZSTD_ErrorCode ERR_enum; #define PREFIX(name) ZSTD_error_##name /*-**************************************** * Error codes handling ******************************************/ #undef ERROR /* reported already defined on VS 2015 (Rich Geldreich) */ #define ERROR(name) ZSTD_ERROR(name) #define ZSTD_ERROR(name) ((size_t)-PREFIX(name)) ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); } ERR_STATIC ERR_enum ERR_getErrorCode(size_t code) { if (!ERR_isError(code)) return (ERR_enum)0; return (ERR_enum) (0-code); } /*-**************************************** * Error Strings ******************************************/ const char* ERR_getErrorString(ERR_enum code); /* error_private.c */ ERR_STATIC const char* ERR_getErrorName(size_t code) { return ERR_getErrorString(ERR_getErrorCode(code)); } #if defined (__cplusplus) } #endif #endif /* ERROR_H_MODULE */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/errors.go ================================================ package zstd /* #define ZSTD_STATIC_LINKING_ONLY #include "zstd.h" */ import "C" // ErrorCode is an error returned by the zstd library. type ErrorCode int // Error returns the error string given by zstd func (e ErrorCode) Error() string { return C.GoString(C.ZSTD_getErrorName(C.size_t(e))) } func cIsError(code int) bool { return int(C.ZSTD_isError(C.size_t(code))) != 0 } // getError returns an error for the return code, or nil if it's not an error func getError(code int) error { if code < 0 && cIsError(code) { return ErrorCode(code) } return nil } // IsDstSizeTooSmallError returns whether the error correspond to zstd standard sDstSizeTooSmall error func IsDstSizeTooSmallError(e error) bool { if e != nil && e.Error() == "Destination buffer is too small" { return true } return false } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/fse.h ================================================ /* ****************************************************************** FSE : Finite State Entropy codec Public Prototypes declaration Copyright (C) 2013-2016, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - Source repository : https://github.com/Cyan4973/FiniteStateEntropy ****************************************************************** */ #if defined (__cplusplus) extern "C" { #endif #ifndef FSE_H #define FSE_H /*-***************************************** * Dependencies ******************************************/ #include /* size_t, ptrdiff_t */ /*-***************************************** * FSE_PUBLIC_API : control library symbols visibility ******************************************/ #if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) && defined(__GNUC__) && (__GNUC__ >= 4) # define FSE_PUBLIC_API __attribute__ ((visibility ("default"))) #elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) /* Visual expected */ # define FSE_PUBLIC_API __declspec(dllexport) #elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPORT==1) # define FSE_PUBLIC_API __declspec(dllimport) /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/ #else # define FSE_PUBLIC_API #endif /*------ Version ------*/ #define FSE_VERSION_MAJOR 0 #define FSE_VERSION_MINOR 9 #define FSE_VERSION_RELEASE 0 #define FSE_LIB_VERSION FSE_VERSION_MAJOR.FSE_VERSION_MINOR.FSE_VERSION_RELEASE #define FSE_QUOTE(str) #str #define FSE_EXPAND_AND_QUOTE(str) FSE_QUOTE(str) #define FSE_VERSION_STRING FSE_EXPAND_AND_QUOTE(FSE_LIB_VERSION) #define FSE_VERSION_NUMBER (FSE_VERSION_MAJOR *100*100 + FSE_VERSION_MINOR *100 + FSE_VERSION_RELEASE) FSE_PUBLIC_API unsigned FSE_versionNumber(void); /**< library version number; to be used when checking dll version */ /*-**************************************** * FSE simple functions ******************************************/ /*! FSE_compress() : Compress content of buffer 'src', of size 'srcSize', into destination buffer 'dst'. 'dst' buffer must be already allocated. Compression runs faster is dstCapacity >= FSE_compressBound(srcSize). @return : size of compressed data (<= dstCapacity). Special values : if return == 0, srcData is not compressible => Nothing is stored within dst !!! if return == 1, srcData is a single byte symbol * srcSize times. Use RLE compression instead. if FSE_isError(return), compression failed (more details using FSE_getErrorName()) */ FSE_PUBLIC_API size_t FSE_compress(void* dst, size_t dstCapacity, const void* src, size_t srcSize); /*! FSE_decompress(): Decompress FSE data from buffer 'cSrc', of size 'cSrcSize', into already allocated destination buffer 'dst', of size 'dstCapacity'. @return : size of regenerated data (<= maxDstSize), or an error code, which can be tested using FSE_isError() . ** Important ** : FSE_decompress() does not decompress non-compressible nor RLE data !!! Why ? : making this distinction requires a header. Header management is intentionally delegated to the user layer, which can better manage special cases. */ FSE_PUBLIC_API size_t FSE_decompress(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize); /*-***************************************** * Tool functions ******************************************/ FSE_PUBLIC_API size_t FSE_compressBound(size_t size); /* maximum compressed size */ /* Error Management */ FSE_PUBLIC_API unsigned FSE_isError(size_t code); /* tells if a return value is an error code */ FSE_PUBLIC_API const char* FSE_getErrorName(size_t code); /* provides error code string (useful for debugging) */ /*-***************************************** * FSE advanced functions ******************************************/ /*! FSE_compress2() : Same as FSE_compress(), but allows the selection of 'maxSymbolValue' and 'tableLog' Both parameters can be defined as '0' to mean : use default value @return : size of compressed data Special values : if return == 0, srcData is not compressible => Nothing is stored within cSrc !!! if return == 1, srcData is a single byte symbol * srcSize times. Use RLE compression. if FSE_isError(return), it's an error code. */ FSE_PUBLIC_API size_t FSE_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog); /*-***************************************** * FSE detailed API ******************************************/ /*! FSE_compress() does the following: 1. count symbol occurrence from source[] into table count[] 2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog) 3. save normalized counters to memory buffer using writeNCount() 4. build encoding table 'CTable' from normalized counters 5. encode the data stream using encoding table 'CTable' FSE_decompress() does the following: 1. read normalized counters with readNCount() 2. build decoding table 'DTable' from normalized counters 3. decode the data stream using decoding table 'DTable' The following API allows targeting specific sub-functions for advanced tasks. For example, it's possible to compress several blocks using the same 'CTable', or to save and provide normalized distribution using external method. */ /* *** COMPRESSION *** */ /*! FSE_count(): Provides the precise count of each byte within a table 'count'. 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1). *maxSymbolValuePtr will be updated if detected smaller than initial value. @return : the count of the most frequent symbol (which is not identified). if return == srcSize, there is only one symbol. Can also return an error code, which can be tested with FSE_isError(). */ FSE_PUBLIC_API size_t FSE_count(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize); /*! FSE_optimalTableLog(): dynamically downsize 'tableLog' when conditions are met. It saves CPU time, by using smaller tables, while preserving or even improving compression ratio. @return : recommended tableLog (necessarily <= 'maxTableLog') */ FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue); /*! FSE_normalizeCount(): normalize counts so that sum(count[]) == Power_of_2 (2^tableLog) 'normalizedCounter' is a table of short, of minimum size (maxSymbolValue+1). @return : tableLog, or an errorCode, which can be tested using FSE_isError() */ FSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog, const unsigned* count, size_t srcSize, unsigned maxSymbolValue); /*! FSE_NCountWriteBound(): Provides the maximum possible size of an FSE normalized table, given 'maxSymbolValue' and 'tableLog'. Typically useful for allocation purpose. */ FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog); /*! FSE_writeNCount(): Compactly save 'normalizedCounter' into 'buffer'. @return : size of the compressed table, or an errorCode, which can be tested using FSE_isError(). */ FSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog); /*! Constructor and Destructor of FSE_CTable. Note that FSE_CTable size depends on 'tableLog' and 'maxSymbolValue' */ typedef unsigned FSE_CTable; /* don't allocate that. It's only meant to be more restrictive than void* */ FSE_PUBLIC_API FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog); FSE_PUBLIC_API void FSE_freeCTable (FSE_CTable* ct); /*! FSE_buildCTable(): Builds `ct`, which must be already allocated, using FSE_createCTable(). @return : 0, or an errorCode, which can be tested using FSE_isError() */ FSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog); /*! FSE_compress_usingCTable(): Compress `src` using `ct` into `dst` which must be already allocated. @return : size of compressed data (<= `dstCapacity`), or 0 if compressed data could not fit into `dst`, or an errorCode, which can be tested using FSE_isError() */ FSE_PUBLIC_API size_t FSE_compress_usingCTable (void* dst, size_t dstCapacity, const void* src, size_t srcSize, const FSE_CTable* ct); /*! Tutorial : ---------- The first step is to count all symbols. FSE_count() does this job very fast. Result will be saved into 'count', a table of unsigned int, which must be already allocated, and have 'maxSymbolValuePtr[0]+1' cells. 'src' is a table of bytes of size 'srcSize'. All values within 'src' MUST be <= maxSymbolValuePtr[0] maxSymbolValuePtr[0] will be updated, with its real value (necessarily <= original value) FSE_count() will return the number of occurrence of the most frequent symbol. This can be used to know if there is a single symbol within 'src', and to quickly evaluate its compressibility. If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()). The next step is to normalize the frequencies. FSE_normalizeCount() will ensure that sum of frequencies is == 2 ^'tableLog'. It also guarantees a minimum of 1 to any Symbol with frequency >= 1. You can use 'tableLog'==0 to mean "use default tableLog value". If you are unsure of which tableLog value to use, you can ask FSE_optimalTableLog(), which will provide the optimal valid tableLog given sourceSize, maxSymbolValue, and a user-defined maximum (0 means "default"). The result of FSE_normalizeCount() will be saved into a table, called 'normalizedCounter', which is a table of signed short. 'normalizedCounter' must be already allocated, and have at least 'maxSymbolValue+1' cells. The return value is tableLog if everything proceeded as expected. It is 0 if there is a single symbol within distribution. If there is an error (ex: invalid tableLog value), the function will return an ErrorCode (which can be tested using FSE_isError()). 'normalizedCounter' can be saved in a compact manner to a memory area using FSE_writeNCount(). 'buffer' must be already allocated. For guaranteed success, buffer size must be at least FSE_headerBound(). The result of the function is the number of bytes written into 'buffer'. If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError(); ex : buffer size too small). 'normalizedCounter' can then be used to create the compression table 'CTable'. The space required by 'CTable' must be already allocated, using FSE_createCTable(). You can then use FSE_buildCTable() to fill 'CTable'. If there is an error, both functions will return an ErrorCode (which can be tested using FSE_isError()). 'CTable' can then be used to compress 'src', with FSE_compress_usingCTable(). Similar to FSE_count(), the convention is that 'src' is assumed to be a table of char of size 'srcSize' The function returns the size of compressed data (without header), necessarily <= `dstCapacity`. If it returns '0', compressed data could not fit into 'dst'. If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()). */ /* *** DECOMPRESSION *** */ /*! FSE_readNCount(): Read compactly saved 'normalizedCounter' from 'rBuffer'. @return : size read from 'rBuffer', or an errorCode, which can be tested using FSE_isError(). maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */ FSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize); /*! Constructor and Destructor of FSE_DTable. Note that its size depends on 'tableLog' */ typedef unsigned FSE_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */ FSE_PUBLIC_API FSE_DTable* FSE_createDTable(unsigned tableLog); FSE_PUBLIC_API void FSE_freeDTable(FSE_DTable* dt); /*! FSE_buildDTable(): Builds 'dt', which must be already allocated, using FSE_createDTable(). return : 0, or an errorCode, which can be tested using FSE_isError() */ FSE_PUBLIC_API size_t FSE_buildDTable (FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog); /*! FSE_decompress_usingDTable(): Decompress compressed source `cSrc` of size `cSrcSize` using `dt` into `dst` which must be already allocated. @return : size of regenerated data (necessarily <= `dstCapacity`), or an errorCode, which can be tested using FSE_isError() */ FSE_PUBLIC_API size_t FSE_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt); /*! Tutorial : ---------- (Note : these functions only decompress FSE-compressed blocks. If block is uncompressed, use memcpy() instead If block is a single repeated byte, use memset() instead ) The first step is to obtain the normalized frequencies of symbols. This can be performed by FSE_readNCount() if it was saved using FSE_writeNCount(). 'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short. In practice, that means it's necessary to know 'maxSymbolValue' beforehand, or size the table to handle worst case situations (typically 256). FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'. The result of FSE_readNCount() is the number of bytes read from 'rBuffer'. Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that. If there is an error, the function will return an error code, which can be tested using FSE_isError(). The next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'. This is performed by the function FSE_buildDTable(). The space required by 'FSE_DTable' must be already allocated using FSE_createDTable(). If there is an error, the function will return an error code, which can be tested using FSE_isError(). `FSE_DTable` can then be used to decompress `cSrc`, with FSE_decompress_usingDTable(). `cSrcSize` must be strictly correct, otherwise decompression will fail. FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`). If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small) */ #endif /* FSE_H */ #if defined(FSE_STATIC_LINKING_ONLY) && !defined(FSE_H_FSE_STATIC_LINKING_ONLY) #define FSE_H_FSE_STATIC_LINKING_ONLY /* *** Dependency *** */ #include "bitstream.h" /* ***************************************** * Static allocation *******************************************/ /* FSE buffer bounds */ #define FSE_NCOUNTBOUND 512 #define FSE_BLOCKBOUND(size) (size + (size>>7)) #define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size)) /* Macro version, useful for static allocation */ /* It is possible to statically allocate FSE CTable/DTable as a table of FSE_CTable/FSE_DTable using below macros */ #define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2)) #define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1<= `1024` unsigned */ size_t FSE_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr, const void* source, size_t sourceSize, unsigned* workSpace); /** FSE_countFast() : * same as FSE_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr */ size_t FSE_countFast(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize); /* FSE_countFast_wksp() : * Same as FSE_countFast(), but using an externally provided scratch buffer. * `workSpace` must be a table of minimum `1024` unsigned */ size_t FSE_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned* workSpace); /*! FSE_count_simple() : * Same as FSE_countFast(), but does not use any additional memory (not even on stack). * This function is unsafe, and will segfault if any value within `src` is `> *maxSymbolValuePtr` (presuming it's also the size of `count`). */ size_t FSE_count_simple(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize); unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus); /**< same as FSE_optimalTableLog(), which used `minus==2` */ /* FSE_compress_wksp() : * Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`). * FSE_WKSP_SIZE_U32() provides the minimum size required for `workSpace` as a table of FSE_CTable. */ #define FSE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) ( FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) + ((maxTableLog > 12) ? (1 << (maxTableLog - 2)) : 1024) ) size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize); size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits); /**< build a fake FSE_CTable, designed for a flat distribution, where each symbol uses nbBits */ size_t FSE_buildCTable_rle (FSE_CTable* ct, unsigned char symbolValue); /**< build a fake FSE_CTable, designed to compress always the same symbolValue */ /* FSE_buildCTable_wksp() : * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`). * `wkspSize` must be >= `(1<= BIT_DStream_completed When it's done, verify decompression is fully completed, by checking both DStream and the relevant states. Checking if DStream has reached its end is performed by : BIT_endOfDStream(&DStream); Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible. FSE_endOfDState(&DState); */ /* ***************************************** * FSE unsafe API *******************************************/ static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD); /* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */ /* ***************************************** * Implementation of inlined functions *******************************************/ typedef struct { int deltaFindState; U32 deltaNbBits; } FSE_symbolCompressionTransform; /* total 8 bytes */ MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct) { const void* ptr = ct; const U16* u16ptr = (const U16*) ptr; const U32 tableLog = MEM_read16(ptr); statePtr->value = (ptrdiff_t)1<stateTable = u16ptr+2; statePtr->symbolTT = ((const U32*)ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1)); statePtr->stateLog = tableLog; } /*! FSE_initCState2() : * Same as FSE_initCState(), but the first symbol to include (which will be the last to be read) * uses the smallest state value possible, saving the cost of this symbol */ MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol) { FSE_initCState(statePtr, ct); { const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol]; const U16* stateTable = (const U16*)(statePtr->stateTable); U32 nbBitsOut = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16); statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits; statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState]; } } MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, U32 symbol) { FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol]; const U16* const stateTable = (const U16*)(statePtr->stateTable); U32 const nbBitsOut = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16); BIT_addBits(bitC, statePtr->value, nbBitsOut); statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState]; } MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePtr) { BIT_addBits(bitC, statePtr->value, statePtr->stateLog); BIT_flushBits(bitC); } /* ====== Decompression ====== */ typedef struct { U16 tableLog; U16 fastMode; } FSE_DTableHeader; /* sizeof U32 */ typedef struct { unsigned short newState; unsigned char symbol; unsigned char nbBits; } FSE_decode_t; /* size == U32 */ MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt) { const void* ptr = dt; const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr; DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog); BIT_reloadDStream(bitD); DStatePtr->table = dt + 1; } MEM_STATIC BYTE FSE_peekSymbol(const FSE_DState_t* DStatePtr) { FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; return DInfo.symbol; } MEM_STATIC void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) { FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; U32 const nbBits = DInfo.nbBits; size_t const lowBits = BIT_readBits(bitD, nbBits); DStatePtr->state = DInfo.newState + lowBits; } MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) { FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; U32 const nbBits = DInfo.nbBits; BYTE const symbol = DInfo.symbol; size_t const lowBits = BIT_readBits(bitD, nbBits); DStatePtr->state = DInfo.newState + lowBits; return symbol; } /*! FSE_decodeSymbolFast() : unsafe, only works if no symbol has a probability > 50% */ MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) { FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; U32 const nbBits = DInfo.nbBits; BYTE const symbol = DInfo.symbol; size_t const lowBits = BIT_readBitsFast(bitD, nbBits); DStatePtr->state = DInfo.newState + lowBits; return symbol; } MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr) { return DStatePtr->state == 0; } #ifndef FSE_COMMONDEFS_ONLY /* ************************************************************** * Tuning parameters ****************************************************************/ /*!MEMORY_USAGE : * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.) * Increasing memory usage improves compression ratio * Reduced memory usage can improve speed, due to cache effect * Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */ #ifndef FSE_MAX_MEMORY_USAGE # define FSE_MAX_MEMORY_USAGE 14 #endif #ifndef FSE_DEFAULT_MEMORY_USAGE # define FSE_DEFAULT_MEMORY_USAGE 13 #endif /*!FSE_MAX_SYMBOL_VALUE : * Maximum symbol value authorized. * Required for proper stack allocation */ #ifndef FSE_MAX_SYMBOL_VALUE # define FSE_MAX_SYMBOL_VALUE 255 #endif /* ************************************************************** * template functions type & suffix ****************************************************************/ #define FSE_FUNCTION_TYPE BYTE #define FSE_FUNCTION_EXTENSION #define FSE_DECODE_TYPE FSE_decode_t #endif /* !FSE_COMMONDEFS_ONLY */ /* *************************************************************** * Constants *****************************************************************/ #define FSE_MAX_TABLELOG (FSE_MAX_MEMORY_USAGE-2) #define FSE_MAX_TABLESIZE (1U< FSE_TABLELOG_ABSOLUTE_MAX # error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported" #endif #define FSE_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3) #endif /* FSE_STATIC_LINKING_ONLY */ #if defined (__cplusplus) } #endif ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/fse_compress.c ================================================ /* ****************************************************************** FSE : Finite State Entropy encoder Copyright (C) 2013-2015, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c ****************************************************************** */ /* ************************************************************** * Includes ****************************************************************/ #include /* malloc, free, qsort */ #include /* memcpy, memset */ #include /* printf (debug) */ #include "bitstream.h" #include "compiler.h" #define FSE_STATIC_LINKING_ONLY #include "fse.h" #include "error_private.h" /* ************************************************************** * Error Management ****************************************************************/ #define FSE_isError ERR_isError #define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ /* ************************************************************** * Templates ****************************************************************/ /* designed to be included for type-specific functions (template emulation in C) Objective is to write these functions only once, for improved maintenance */ /* safety checks */ #ifndef FSE_FUNCTION_EXTENSION # error "FSE_FUNCTION_EXTENSION must be defined" #endif #ifndef FSE_FUNCTION_TYPE # error "FSE_FUNCTION_TYPE must be defined" #endif /* Function names */ #define FSE_CAT(X,Y) X##Y #define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y) #define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y) /* Function templates */ /* FSE_buildCTable_wksp() : * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`). * wkspSize should be sized to handle worst case situation, which is `1<>1 : 1) ; FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT); U32 const step = FSE_TABLESTEP(tableSize); U32 cumul[FSE_MAX_SYMBOL_VALUE+2]; FSE_FUNCTION_TYPE* const tableSymbol = (FSE_FUNCTION_TYPE*)workSpace; U32 highThreshold = tableSize-1; /* CTable header */ if (((size_t)1 << tableLog) * sizeof(FSE_FUNCTION_TYPE) > wkspSize) return ERROR(tableLog_tooLarge); tableU16[-2] = (U16) tableLog; tableU16[-1] = (U16) maxSymbolValue; /* For explanations on how to distribute symbol values over the table : * http://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */ /* symbol start positions */ { U32 u; cumul[0] = 0; for (u=1; u<=maxSymbolValue+1; u++) { if (normalizedCounter[u-1]==-1) { /* Low proba symbol */ cumul[u] = cumul[u-1] + 1; tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1); } else { cumul[u] = cumul[u-1] + normalizedCounter[u-1]; } } cumul[maxSymbolValue+1] = tableSize+1; } /* Spread symbols */ { U32 position = 0; U32 symbol; for (symbol=0; symbol<=maxSymbolValue; symbol++) { int nbOccurences; for (nbOccurences=0; nbOccurences highThreshold) position = (position + step) & tableMask; /* Low proba area */ } } if (position!=0) return ERROR(GENERIC); /* Must have gone through all positions */ } /* Build table */ { U32 u; for (u=0; u> 3) + 3; return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND; /* maxSymbolValue==0 ? use default */ } static size_t FSE_writeNCount_generic (void* header, size_t headerBufferSize, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, unsigned writeIsSafe) { BYTE* const ostart = (BYTE*) header; BYTE* out = ostart; BYTE* const oend = ostart + headerBufferSize; int nbBits; const int tableSize = 1 << tableLog; int remaining; int threshold; U32 bitStream; int bitCount; unsigned charnum = 0; int previous0 = 0; bitStream = 0; bitCount = 0; /* Table Size */ bitStream += (tableLog-FSE_MIN_TABLELOG) << bitCount; bitCount += 4; /* Init */ remaining = tableSize+1; /* +1 for extra accuracy */ threshold = tableSize; nbBits = tableLog+1; while (remaining>1) { /* stops at 1 */ if (previous0) { unsigned start = charnum; while (!normalizedCounter[charnum]) charnum++; while (charnum >= start+24) { start+=24; bitStream += 0xFFFFU << bitCount; if ((!writeIsSafe) && (out > oend-2)) return ERROR(dstSize_tooSmall); /* Buffer overflow */ out[0] = (BYTE) bitStream; out[1] = (BYTE)(bitStream>>8); out+=2; bitStream>>=16; } while (charnum >= start+3) { start+=3; bitStream += 3 << bitCount; bitCount += 2; } bitStream += (charnum-start) << bitCount; bitCount += 2; if (bitCount>16) { if ((!writeIsSafe) && (out > oend - 2)) return ERROR(dstSize_tooSmall); /* Buffer overflow */ out[0] = (BYTE)bitStream; out[1] = (BYTE)(bitStream>>8); out += 2; bitStream >>= 16; bitCount -= 16; } } { int count = normalizedCounter[charnum++]; int const max = (2*threshold-1)-remaining; remaining -= count < 0 ? -count : count; count++; /* +1 for extra accuracy */ if (count>=threshold) count += max; /* [0..max[ [max..threshold[ (...) [threshold+max 2*threshold[ */ bitStream += count << bitCount; bitCount += nbBits; bitCount -= (count>=1; } } if (bitCount>16) { if ((!writeIsSafe) && (out > oend - 2)) return ERROR(dstSize_tooSmall); /* Buffer overflow */ out[0] = (BYTE)bitStream; out[1] = (BYTE)(bitStream>>8); out += 2; bitStream >>= 16; bitCount -= 16; } } /* flush remaining bitStream */ if ((!writeIsSafe) && (out > oend - 2)) return ERROR(dstSize_tooSmall); /* Buffer overflow */ out[0] = (BYTE)bitStream; out[1] = (BYTE)(bitStream>>8); out+= (bitCount+7) /8; if (charnum > maxSymbolValue + 1) return ERROR(GENERIC); return (out-ostart); } size_t FSE_writeNCount (void* buffer, size_t bufferSize, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) { if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge); /* Unsupported */ if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC); /* Unsupported */ if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog)) return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 0); return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1); } /*-************************************************************** * Counting histogram ****************************************************************/ /*! FSE_count_simple This function counts byte values within `src`, and store the histogram into table `count`. It doesn't use any additional memory. But this function is unsafe : it doesn't check that all values within `src` can fit into `count`. For this reason, prefer using a table `count` with 256 elements. @return : count of most numerous element. */ size_t FSE_count_simple(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize) { const BYTE* ip = (const BYTE*)src; const BYTE* const end = ip + srcSize; unsigned maxSymbolValue = *maxSymbolValuePtr; unsigned max=0; memset(count, 0, (maxSymbolValue+1)*sizeof(*count)); if (srcSize==0) { *maxSymbolValuePtr = 0; return 0; } while (ip max) max = count[s]; } return (size_t)max; } /* FSE_count_parallel_wksp() : * Same as FSE_count_parallel(), but using an externally provided scratch buffer. * `workSpace` size must be a minimum of `1024 * sizeof(unsigned)`. * @return : largest histogram frequency, or an error code (notably when histogram would be larger than *maxSymbolValuePtr). */ static size_t FSE_count_parallel_wksp( unsigned* count, unsigned* maxSymbolValuePtr, const void* source, size_t sourceSize, unsigned checkMax, unsigned* const workSpace) { const BYTE* ip = (const BYTE*)source; const BYTE* const iend = ip+sourceSize; unsigned maxSymbolValue = *maxSymbolValuePtr; unsigned max=0; U32* const Counting1 = workSpace; U32* const Counting2 = Counting1 + 256; U32* const Counting3 = Counting2 + 256; U32* const Counting4 = Counting3 + 256; memset(workSpace, 0, 4*256*sizeof(unsigned)); /* safety checks */ if (!sourceSize) { memset(count, 0, maxSymbolValue + 1); *maxSymbolValuePtr = 0; return 0; } if (!maxSymbolValue) maxSymbolValue = 255; /* 0 == default */ /* by stripes of 16 bytes */ { U32 cached = MEM_read32(ip); ip += 4; while (ip < iend-15) { U32 c = cached; cached = MEM_read32(ip); ip += 4; Counting1[(BYTE) c ]++; Counting2[(BYTE)(c>>8) ]++; Counting3[(BYTE)(c>>16)]++; Counting4[ c>>24 ]++; c = cached; cached = MEM_read32(ip); ip += 4; Counting1[(BYTE) c ]++; Counting2[(BYTE)(c>>8) ]++; Counting3[(BYTE)(c>>16)]++; Counting4[ c>>24 ]++; c = cached; cached = MEM_read32(ip); ip += 4; Counting1[(BYTE) c ]++; Counting2[(BYTE)(c>>8) ]++; Counting3[(BYTE)(c>>16)]++; Counting4[ c>>24 ]++; c = cached; cached = MEM_read32(ip); ip += 4; Counting1[(BYTE) c ]++; Counting2[(BYTE)(c>>8) ]++; Counting3[(BYTE)(c>>16)]++; Counting4[ c>>24 ]++; } ip-=4; } /* finish last symbols */ while (ipmaxSymbolValue; s--) { Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s]; if (Counting1[s]) return ERROR(maxSymbolValue_tooSmall); } } { U32 s; if (maxSymbolValue > 255) maxSymbolValue = 255; for (s=0; s<=maxSymbolValue; s++) { count[s] = Counting1[s] + Counting2[s] + Counting3[s] + Counting4[s]; if (count[s] > max) max = count[s]; } } while (!count[maxSymbolValue]) maxSymbolValue--; *maxSymbolValuePtr = maxSymbolValue; return (size_t)max; } /* FSE_countFast_wksp() : * Same as FSE_countFast(), but using an externally provided scratch buffer. * `workSpace` size must be table of >= `1024` unsigned */ size_t FSE_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr, const void* source, size_t sourceSize, unsigned* workSpace) { if (sourceSize < 1500) /* heuristic threshold */ return FSE_count_simple(count, maxSymbolValuePtr, source, sourceSize); return FSE_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, 0, workSpace); } /* fast variant (unsafe : won't check if src contains values beyond count[] limit) */ size_t FSE_countFast(unsigned* count, unsigned* maxSymbolValuePtr, const void* source, size_t sourceSize) { unsigned tmpCounters[1024]; return FSE_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters); } /* FSE_count_wksp() : * Same as FSE_count(), but using an externally provided scratch buffer. * `workSpace` size must be table of >= `1024` unsigned */ size_t FSE_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr, const void* source, size_t sourceSize, unsigned* workSpace) { if (*maxSymbolValuePtr < 255) return FSE_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, 1, workSpace); *maxSymbolValuePtr = 255; return FSE_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace); } size_t FSE_count(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize) { unsigned tmpCounters[1024]; return FSE_count_wksp(count, maxSymbolValuePtr, src, srcSize, tmpCounters); } /*-************************************************************** * FSE Compression Code ****************************************************************/ /*! FSE_sizeof_CTable() : FSE_CTable is a variable size structure which contains : `U16 tableLog;` `U16 maxSymbolValue;` `U16 nextStateNumber[1 << tableLog];` // This size is variable `FSE_symbolCompressionTransform symbolTT[maxSymbolValue+1];` // This size is variable Allocation is manual (C standard does not support variable-size structures). */ size_t FSE_sizeof_CTable (unsigned maxSymbolValue, unsigned tableLog) { if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge); return FSE_CTABLE_SIZE_U32 (tableLog, maxSymbolValue) * sizeof(U32); } FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog) { size_t size; if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX; size = FSE_CTABLE_SIZE_U32 (tableLog, maxSymbolValue) * sizeof(U32); return (FSE_CTable*)malloc(size); } void FSE_freeCTable (FSE_CTable* ct) { free(ct); } /* provides the minimum logSize to safely represent a distribution */ static unsigned FSE_minTableLog(size_t srcSize, unsigned maxSymbolValue) { U32 minBitsSrc = BIT_highbit32((U32)(srcSize - 1)) + 1; U32 minBitsSymbols = BIT_highbit32(maxSymbolValue) + 2; U32 minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols; assert(srcSize > 1); /* Not supported, RLE should be used instead */ return minBits; } unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus) { U32 maxBitsSrc = BIT_highbit32((U32)(srcSize - 1)) - minus; U32 tableLog = maxTableLog; U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue); assert(srcSize > 1); /* Not supported, RLE should be used instead */ if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG; if (maxBitsSrc < tableLog) tableLog = maxBitsSrc; /* Accuracy can be reduced */ if (minBits > tableLog) tableLog = minBits; /* Need a minimum to safely represent all symbol values */ if (tableLog < FSE_MIN_TABLELOG) tableLog = FSE_MIN_TABLELOG; if (tableLog > FSE_MAX_TABLELOG) tableLog = FSE_MAX_TABLELOG; return tableLog; } unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue) { return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 2); } /* Secondary normalization method. To be used when primary method fails. */ static size_t FSE_normalizeM2(short* norm, U32 tableLog, const unsigned* count, size_t total, U32 maxSymbolValue) { short const NOT_YET_ASSIGNED = -2; U32 s; U32 distributed = 0; U32 ToDistribute; /* Init */ U32 const lowThreshold = (U32)(total >> tableLog); U32 lowOne = (U32)((total * 3) >> (tableLog + 1)); for (s=0; s<=maxSymbolValue; s++) { if (count[s] == 0) { norm[s]=0; continue; } if (count[s] <= lowThreshold) { norm[s] = -1; distributed++; total -= count[s]; continue; } if (count[s] <= lowOne) { norm[s] = 1; distributed++; total -= count[s]; continue; } norm[s]=NOT_YET_ASSIGNED; } ToDistribute = (1 << tableLog) - distributed; if ((total / ToDistribute) > lowOne) { /* risk of rounding to zero */ lowOne = (U32)((total * 3) / (ToDistribute * 2)); for (s=0; s<=maxSymbolValue; s++) { if ((norm[s] == NOT_YET_ASSIGNED) && (count[s] <= lowOne)) { norm[s] = 1; distributed++; total -= count[s]; continue; } } ToDistribute = (1 << tableLog) - distributed; } if (distributed == maxSymbolValue+1) { /* all values are pretty poor; probably incompressible data (should have already been detected); find max, then give all remaining points to max */ U32 maxV = 0, maxC = 0; for (s=0; s<=maxSymbolValue; s++) if (count[s] > maxC) { maxV=s; maxC=count[s]; } norm[maxV] += (short)ToDistribute; return 0; } if (total == 0) { /* all of the symbols were low enough for the lowOne or lowThreshold */ for (s=0; ToDistribute > 0; s = (s+1)%(maxSymbolValue+1)) if (norm[s] > 0) { ToDistribute--; norm[s]++; } return 0; } { U64 const vStepLog = 62 - tableLog; U64 const mid = (1ULL << (vStepLog-1)) - 1; U64 const rStep = ((((U64)1<> vStepLog); U32 const sEnd = (U32)(end >> vStepLog); U32 const weight = sEnd - sStart; if (weight < 1) return ERROR(GENERIC); norm[s] = (short)weight; tmpTotal = end; } } } return 0; } size_t FSE_normalizeCount (short* normalizedCounter, unsigned tableLog, const unsigned* count, size_t total, unsigned maxSymbolValue) { /* Sanity checks */ if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG; if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC); /* Unsupported size */ if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge); /* Unsupported size */ if (tableLog < FSE_minTableLog(total, maxSymbolValue)) return ERROR(GENERIC); /* Too small tableLog, compression potentially impossible */ { static U32 const rtbTable[] = { 0, 473195, 504333, 520860, 550000, 700000, 750000, 830000 }; U64 const scale = 62 - tableLog; U64 const step = ((U64)1<<62) / total; /* <== here, one division ! */ U64 const vStep = 1ULL<<(scale-20); int stillToDistribute = 1<> tableLog); for (s=0; s<=maxSymbolValue; s++) { if (count[s] == total) return 0; /* rle special case */ if (count[s] == 0) { normalizedCounter[s]=0; continue; } if (count[s] <= lowThreshold) { normalizedCounter[s] = -1; stillToDistribute--; } else { short proba = (short)((count[s]*step) >> scale); if (proba<8) { U64 restToBeat = vStep * rtbTable[proba]; proba += (count[s]*step) - ((U64)proba< restToBeat; } if (proba > largestP) { largestP=proba; largest=s; } normalizedCounter[s] = proba; stillToDistribute -= proba; } } if (-stillToDistribute >= (normalizedCounter[largest] >> 1)) { /* corner case, need another normalization method */ size_t const errorCode = FSE_normalizeM2(normalizedCounter, tableLog, count, total, maxSymbolValue); if (FSE_isError(errorCode)) return errorCode; } else normalizedCounter[largest] += (short)stillToDistribute; } #if 0 { /* Print Table (debug) */ U32 s; U32 nTotal = 0; for (s=0; s<=maxSymbolValue; s++) printf("%3i: %4i \n", s, normalizedCounter[s]); for (s=0; s<=maxSymbolValue; s++) nTotal += abs(normalizedCounter[s]); if (nTotal != (1U<>1); /* assumption : tableLog >= 1 */ FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT); unsigned s; /* Sanity checks */ if (nbBits < 1) return ERROR(GENERIC); /* min size */ /* header */ tableU16[-2] = (U16) nbBits; tableU16[-1] = (U16) maxSymbolValue; /* Build table */ for (s=0; s FSE_MAX_TABLELOG*4+7 ) && (srcSize & 2)) { /* test bit 2 */ FSE_encodeSymbol(&bitC, &CState2, *--ip); FSE_encodeSymbol(&bitC, &CState1, *--ip); FSE_FLUSHBITS(&bitC); } /* 2 or 4 encoding per loop */ while ( ip>istart ) { FSE_encodeSymbol(&bitC, &CState2, *--ip); if (sizeof(bitC.bitContainer)*8 < FSE_MAX_TABLELOG*2+7 ) /* this test must be static */ FSE_FLUSHBITS(&bitC); FSE_encodeSymbol(&bitC, &CState1, *--ip); if (sizeof(bitC.bitContainer)*8 > FSE_MAX_TABLELOG*4+7 ) { /* this test must be static */ FSE_encodeSymbol(&bitC, &CState2, *--ip); FSE_encodeSymbol(&bitC, &CState1, *--ip); } FSE_FLUSHBITS(&bitC); } FSE_flushCState(&bitC, &CState2); FSE_flushCState(&bitC, &CState1); return BIT_closeCStream(&bitC); } size_t FSE_compress_usingCTable (void* dst, size_t dstSize, const void* src, size_t srcSize, const FSE_CTable* ct) { unsigned const fast = (dstSize >= FSE_BLOCKBOUND(srcSize)); if (fast) return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 1); else return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 0); } size_t FSE_compressBound(size_t size) { return FSE_COMPRESSBOUND(size); } #define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e #define CHECK_F(f) { CHECK_V_F(_var_err__, f); } /* FSE_compress_wksp() : * Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`). * `wkspSize` size must be `(1< not compressible */ if (maxCount < (srcSize >> 7)) return 0; /* Heuristic : not compressible enough */ } tableLog = FSE_optimalTableLog(tableLog, srcSize, maxSymbolValue); CHECK_F( FSE_normalizeCount(norm, tableLog, count, srcSize, maxSymbolValue) ); /* Write table description header */ { CHECK_V_F(nc_err, FSE_writeNCount(op, oend-op, norm, maxSymbolValue, tableLog) ); op += nc_err; } /* Compress */ CHECK_F( FSE_buildCTable_wksp(CTable, norm, maxSymbolValue, tableLog, scratchBuffer, scratchBufferSize) ); { CHECK_V_F(cSize, FSE_compress_usingCTable(op, oend - op, src, srcSize, CTable) ); if (cSize == 0) return 0; /* not enough space for compressed data */ op += cSize; } /* check compressibility */ if ( (size_t)(op-ostart) >= srcSize-1 ) return 0; return op-ostart; } typedef struct { FSE_CTable CTable_max[FSE_CTABLE_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)]; BYTE scratchBuffer[1 << FSE_MAX_TABLELOG]; } fseWkspMax_t; size_t FSE_compress2 (void* dst, size_t dstCapacity, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog) { fseWkspMax_t scratchBuffer; FSE_STATIC_ASSERT(sizeof(scratchBuffer) >= FSE_WKSP_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)); /* compilation failures here means scratchBuffer is not large enough */ if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge); return FSE_compress_wksp(dst, dstCapacity, src, srcSize, maxSymbolValue, tableLog, &scratchBuffer, sizeof(scratchBuffer)); } size_t FSE_compress (void* dst, size_t dstCapacity, const void* src, size_t srcSize) { return FSE_compress2(dst, dstCapacity, src, srcSize, FSE_MAX_SYMBOL_VALUE, FSE_DEFAULT_TABLELOG); } #endif /* FSE_COMMONDEFS_ONLY */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/fse_decompress.c ================================================ /* ****************************************************************** FSE : Finite State Entropy decoder Copyright (C) 2013-2015, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c ****************************************************************** */ /* ************************************************************** * Includes ****************************************************************/ #include /* malloc, free, qsort */ #include /* memcpy, memset */ #include "bitstream.h" #include "compiler.h" #define FSE_STATIC_LINKING_ONLY #include "fse.h" #include "error_private.h" /* ************************************************************** * Error Management ****************************************************************/ #define FSE_isError ERR_isError #define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ /* check and forward error code */ #define CHECK_F(f) { size_t const e = f; if (FSE_isError(e)) return e; } /* ************************************************************** * Templates ****************************************************************/ /* designed to be included for type-specific functions (template emulation in C) Objective is to write these functions only once, for improved maintenance */ /* safety checks */ #ifndef FSE_FUNCTION_EXTENSION # error "FSE_FUNCTION_EXTENSION must be defined" #endif #ifndef FSE_FUNCTION_TYPE # error "FSE_FUNCTION_TYPE must be defined" #endif /* Function names */ #define FSE_CAT(X,Y) X##Y #define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y) #define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y) /* Function templates */ FSE_DTable* FSE_createDTable (unsigned tableLog) { if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX; return (FSE_DTable*)malloc( FSE_DTABLE_SIZE_U32(tableLog) * sizeof (U32) ); } void FSE_freeDTable (FSE_DTable* dt) { free(dt); } size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) { void* const tdPtr = dt+1; /* because *dt is unsigned, 32-bits aligned on 32-bits */ FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr); U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1]; U32 const maxSV1 = maxSymbolValue + 1; U32 const tableSize = 1 << tableLog; U32 highThreshold = tableSize-1; /* Sanity Checks */ if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge); if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge); /* Init, lay down lowprob symbols */ { FSE_DTableHeader DTableH; DTableH.tableLog = (U16)tableLog; DTableH.fastMode = 1; { S16 const largeLimit= (S16)(1 << (tableLog-1)); U32 s; for (s=0; s= largeLimit) DTableH.fastMode=0; symbolNext[s] = normalizedCounter[s]; } } } memcpy(dt, &DTableH, sizeof(DTableH)); } /* Spread symbols */ { U32 const tableMask = tableSize-1; U32 const step = FSE_TABLESTEP(tableSize); U32 s, position = 0; for (s=0; s highThreshold) position = (position + step) & tableMask; /* lowprob area */ } } if (position!=0) return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */ } /* Build Decoding table */ { U32 u; for (u=0; utableLog = 0; DTableH->fastMode = 0; cell->newState = 0; cell->symbol = symbolValue; cell->nbBits = 0; return 0; } size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits) { void* ptr = dt; FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; void* dPtr = dt + 1; FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr; const unsigned tableSize = 1 << nbBits; const unsigned tableMask = tableSize - 1; const unsigned maxSV1 = tableMask+1; unsigned s; /* Sanity checks */ if (nbBits < 1) return ERROR(GENERIC); /* min size */ /* Build Decoding Table */ DTableH->tableLog = (U16)nbBits; DTableH->fastMode = 1; for (s=0; s sizeof(bitD.bitContainer)*8) /* This test must be static */ BIT_reloadDStream(&bitD); op[1] = FSE_GETSYMBOL(&state2); if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */ { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } } op[2] = FSE_GETSYMBOL(&state1); if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */ BIT_reloadDStream(&bitD); op[3] = FSE_GETSYMBOL(&state2); } /* tail */ /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */ while (1) { if (op>(omax-2)) return ERROR(dstSize_tooSmall); *op++ = FSE_GETSYMBOL(&state1); if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) { *op++ = FSE_GETSYMBOL(&state2); break; } if (op>(omax-2)) return ERROR(dstSize_tooSmall); *op++ = FSE_GETSYMBOL(&state2); if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) { *op++ = FSE_GETSYMBOL(&state1); break; } } return op-ostart; } size_t FSE_decompress_usingDTable(void* dst, size_t originalSize, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt) { const void* ptr = dt; const FSE_DTableHeader* DTableH = (const FSE_DTableHeader*)ptr; const U32 fastMode = DTableH->fastMode; /* select fast mode (static) */ if (fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); } size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, FSE_DTable* workSpace, unsigned maxLog) { const BYTE* const istart = (const BYTE*)cSrc; const BYTE* ip = istart; short counting[FSE_MAX_SYMBOL_VALUE+1]; unsigned tableLog; unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE; /* normal FSE decoding mode */ size_t const NCountLength = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); if (FSE_isError(NCountLength)) return NCountLength; //if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong); /* too small input size; supposed to be already checked in NCountLength, only remaining case : NCountLength==cSrcSize */ if (tableLog > maxLog) return ERROR(tableLog_tooLarge); ip += NCountLength; cSrcSize -= NCountLength; CHECK_F( FSE_buildDTable (workSpace, counting, maxSymbolValue, tableLog) ); return FSE_decompress_usingDTable (dst, dstCapacity, ip, cSrcSize, workSpace); /* always return, even if it is an error code */ } typedef FSE_DTable DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)]; size_t FSE_decompress(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize) { DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */ return FSE_decompress_wksp(dst, dstCapacity, cSrc, cSrcSize, dt, FSE_MAX_TABLELOG); } #endif /* FSE_COMMONDEFS_ONLY */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/huf.h ================================================ /* ****************************************************************** Huffman coder, part of New Generation Entropy library header file Copyright (C) 2013-2016, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - Source repository : https://github.com/Cyan4973/FiniteStateEntropy ****************************************************************** */ #if defined (__cplusplus) extern "C" { #endif #ifndef HUF_H_298734234 #define HUF_H_298734234 /* *** Dependencies *** */ #include /* size_t */ /* *** library symbols visibility *** */ /* Note : when linking with -fvisibility=hidden on gcc, or by default on Visual, * HUF symbols remain "private" (internal symbols for library only). * Set macro FSE_DLL_EXPORT to 1 if you want HUF symbols visible on DLL interface */ #if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) && defined(__GNUC__) && (__GNUC__ >= 4) # define HUF_PUBLIC_API __attribute__ ((visibility ("default"))) #elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) /* Visual expected */ # define HUF_PUBLIC_API __declspec(dllexport) #elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPORT==1) # define HUF_PUBLIC_API __declspec(dllimport) /* not required, just to generate faster code (saves a function pointer load from IAT and an indirect jump) */ #else # define HUF_PUBLIC_API #endif /* ========================== */ /* *** simple functions *** */ /* ========================== */ /** HUF_compress() : * Compress content from buffer 'src', of size 'srcSize', into buffer 'dst'. * 'dst' buffer must be already allocated. * Compression runs faster if `dstCapacity` >= HUF_compressBound(srcSize). * `srcSize` must be <= `HUF_BLOCKSIZE_MAX` == 128 KB. * @return : size of compressed data (<= `dstCapacity`). * Special values : if return == 0, srcData is not compressible => Nothing is stored within dst !!! * if HUF_isError(return), compression failed (more details using HUF_getErrorName()) */ HUF_PUBLIC_API size_t HUF_compress(void* dst, size_t dstCapacity, const void* src, size_t srcSize); /** HUF_decompress() : * Decompress HUF data from buffer 'cSrc', of size 'cSrcSize', * into already allocated buffer 'dst', of minimum size 'dstSize'. * `originalSize` : **must** be the ***exact*** size of original (uncompressed) data. * Note : in contrast with FSE, HUF_decompress can regenerate * RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data, * because it knows size to regenerate (originalSize). * @return : size of regenerated data (== originalSize), * or an error code, which can be tested using HUF_isError() */ HUF_PUBLIC_API size_t HUF_decompress(void* dst, size_t originalSize, const void* cSrc, size_t cSrcSize); /* *** Tool functions *** */ #define HUF_BLOCKSIZE_MAX (128 * 1024) /**< maximum input size for a single block compressed with HUF_compress */ HUF_PUBLIC_API size_t HUF_compressBound(size_t size); /**< maximum compressed size (worst case) */ /* Error Management */ HUF_PUBLIC_API unsigned HUF_isError(size_t code); /**< tells if a return value is an error code */ HUF_PUBLIC_API const char* HUF_getErrorName(size_t code); /**< provides error code string (useful for debugging) */ /* *** Advanced function *** */ /** HUF_compress2() : * Same as HUF_compress(), but offers control over `maxSymbolValue` and `tableLog`. * `maxSymbolValue` must be <= HUF_SYMBOLVALUE_MAX . * `tableLog` must be `<= HUF_TABLELOG_MAX` . */ HUF_PUBLIC_API size_t HUF_compress2 (void* dst, size_t dstCapacity, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog); /** HUF_compress4X_wksp() : * Same as HUF_compress2(), but uses externally allocated `workSpace`. * `workspace` must have minimum alignment of 4, and be at least as large as HUF_WORKSPACE_SIZE */ #define HUF_WORKSPACE_SIZE (6 << 10) #define HUF_WORKSPACE_SIZE_U32 (HUF_WORKSPACE_SIZE / sizeof(U32)) HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize); #endif /* HUF_H_298734234 */ /* ****************************************************************** * WARNING !! * The following section contains advanced and experimental definitions * which shall never be used in the context of a dynamic library, * because they are not guaranteed to remain stable in the future. * Only consider them in association with static linking. * *****************************************************************/ #if defined(HUF_STATIC_LINKING_ONLY) && !defined(HUF_H_HUF_STATIC_LINKING_ONLY) #define HUF_H_HUF_STATIC_LINKING_ONLY /* *** Dependencies *** */ #include "mem.h" /* U32 */ /* *** Constants *** */ #define HUF_TABLELOG_MAX 12 /* max runtime value of tableLog (due to static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */ #define HUF_TABLELOG_DEFAULT 11 /* default tableLog value when none specified */ #define HUF_SYMBOLVALUE_MAX 255 #define HUF_TABLELOG_ABSOLUTEMAX 15 /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */ #if (HUF_TABLELOG_MAX > HUF_TABLELOG_ABSOLUTEMAX) # error "HUF_TABLELOG_MAX is too large !" #endif /* **************************************** * Static allocation ******************************************/ /* HUF buffer bounds */ #define HUF_CTABLEBOUND 129 #define HUF_BLOCKBOUND(size) (size + (size>>8) + 8) /* only true when incompressible is pre-filtered with fast heuristic */ #define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size)) /* Macro version, useful for static allocation */ /* static allocation of HUF's Compression Table */ #define HUF_CTABLE_SIZE_U32(maxSymbolValue) ((maxSymbolValue)+1) /* Use tables of U32, for proper alignment */ #define HUF_CTABLE_SIZE(maxSymbolValue) (HUF_CTABLE_SIZE_U32(maxSymbolValue) * sizeof(U32)) #define HUF_CREATE_STATIC_CTABLE(name, maxSymbolValue) \ U32 name##hb[HUF_CTABLE_SIZE_U32(maxSymbolValue)]; \ void* name##hv = &(name##hb); \ HUF_CElt* name = (HUF_CElt*)(name##hv) /* no final ; */ /* static allocation of HUF's DTable */ typedef U32 HUF_DTable; #define HUF_DTABLE_SIZE(maxTableLog) (1 + (1<<(maxTableLog))) #define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \ HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) } #define HUF_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \ HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) } /* **************************************** * Advanced decompression functions ******************************************/ size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */ size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */ size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< decodes RLE and uncompressed */ size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */ size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< considers RLE and uncompressed as errors */ size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */ size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< single-symbol decoder */ size_t HUF_decompress4X4_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */ size_t HUF_decompress4X4_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< double-symbols decoder */ /* **************************************** * HUF detailed API * ****************************************/ /*! HUF_compress() does the following: * 1. count symbol occurrence from source[] into table count[] using FSE_count() (exposed within "fse.h") * 2. (optional) refine tableLog using HUF_optimalTableLog() * 3. build Huffman table from count using HUF_buildCTable() * 4. save Huffman table to memory buffer using HUF_writeCTable() * 5. encode the data stream using HUF_compress4X_usingCTable() * * The following API allows targeting specific sub-functions for advanced tasks. * For example, it's possible to compress several blocks using the same 'CTable', * or to save and regenerate 'CTable' using external methods. */ unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue); typedef struct HUF_CElt_s HUF_CElt; /* incomplete type */ size_t HUF_buildCTable (HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits); /* @return : maxNbBits; CTable and count can overlap. In which case, CTable will overwrite count content */ size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog); size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable); typedef enum { HUF_repeat_none, /**< Cannot use the previous table */ HUF_repeat_check, /**< Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1, 4}X_repeat */ HUF_repeat_valid /**< Can use the previous table and it is asumed to be valid */ } HUF_repeat; /** HUF_compress4X_repeat() : * Same as HUF_compress4X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none. * If it uses hufTable it does not modify hufTable or repeat. * If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used. * If preferRepeat then the old table will always be used if valid. */ size_t HUF_compress4X_repeat(void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize, /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */ HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2); /** HUF_buildCTable_wksp() : * Same as HUF_buildCTable(), but using externally allocated scratch buffer. * `workSpace` must be aligned on 4-bytes boundaries, and its size must be >= HUF_CTABLE_WORKSPACE_SIZE. */ #define HUF_CTABLE_WORKSPACE_SIZE_U32 (2*HUF_SYMBOLVALUE_MAX +1 +1) #define HUF_CTABLE_WORKSPACE_SIZE (HUF_CTABLE_WORKSPACE_SIZE_U32 * sizeof(unsigned)) size_t HUF_buildCTable_wksp (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32 maxNbBits, void* workSpace, size_t wkspSize); /*! HUF_readStats() : * Read compact Huffman tree, saved by HUF_writeCTable(). * `huffWeight` is destination buffer. * @return : size read from `src` , or an error Code . * Note : Needed by HUF_readCTable() and HUF_readDTableXn() . */ size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr, const void* src, size_t srcSize); /** HUF_readCTable() : * Loading a CTable saved with HUF_writeCTable() */ size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize); /* * HUF_decompress() does the following: * 1. select the decompression algorithm (X2, X4) based on pre-computed heuristics * 2. build Huffman table from save, using HUF_readDTableX?() * 3. decode 1 or 4 segments in parallel using HUF_decompress?X?_usingDTable() */ /** HUF_selectDecoder() : * Tells which decoder is likely to decode faster, * based on a set of pre-computed metrics. * @return : 0==HUF_decompress4X2, 1==HUF_decompress4X4 . * Assumption : 0 < dstSize <= 128 KB */ U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize); /** * The minimum workspace size for the `workSpace` used in * HUF_readDTableX2_wksp() and HUF_readDTableX4_wksp(). * * The space used depends on HUF_TABLELOG_MAX, ranging from ~1500 bytes when * HUF_TABLE_LOG_MAX=12 to ~1850 bytes when HUF_TABLE_LOG_MAX=15. * Buffer overflow errors may potentially occur if code modifications result in * a required workspace size greater than that specified in the following * macro. */ #define HUF_DECOMPRESS_WORKSPACE_SIZE (2 << 10) #define HUF_DECOMPRESS_WORKSPACE_SIZE_U32 (HUF_DECOMPRESS_WORKSPACE_SIZE / sizeof(U32)) size_t HUF_readDTableX2 (HUF_DTable* DTable, const void* src, size_t srcSize); size_t HUF_readDTableX2_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize); size_t HUF_readDTableX4 (HUF_DTable* DTable, const void* src, size_t srcSize); size_t HUF_readDTableX4_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize); size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); size_t HUF_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); /* ====================== */ /* single stream variants */ /* ====================== */ size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog); size_t HUF_compress1X_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize); /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */ size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable); /** HUF_compress1X_repeat() : * Same as HUF_compress1X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none. * If it uses hufTable it does not modify hufTable or repeat. * If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used. * If preferRepeat then the old table will always be used if valid. */ size_t HUF_compress1X_repeat(void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize, /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */ HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2); size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* single-symbol decoder */ size_t HUF_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /* double-symbol decoder */ size_t HUF_decompress1X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); size_t HUF_decompress1X_DCtx_wksp (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); size_t HUF_decompress1X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< single-symbol decoder */ size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< single-symbol decoder */ size_t HUF_decompress1X4_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< double-symbols decoder */ size_t HUF_decompress1X4_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< double-symbols decoder */ size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); /**< automatic selection of sing or double symbol decoder, based on DTable */ size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); size_t HUF_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); /* BMI2 variants. * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0. */ size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2); size_t HUF_decompress1X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2); size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2); size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2); #endif /* HUF_STATIC_LINKING_ONLY */ #if defined (__cplusplus) } #endif ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/huf_compress.c ================================================ /* ****************************************************************** Huffman encoder, part of New Generation Entropy library Copyright (C) 2013-2016, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c ****************************************************************** */ /* ************************************************************** * Compiler specifics ****************************************************************/ #ifdef _MSC_VER /* Visual Studio */ # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ #endif /* ************************************************************** * Includes ****************************************************************/ #include /* memcpy, memset */ #include /* printf (debug) */ #include "bitstream.h" #include "compiler.h" #define FSE_STATIC_LINKING_ONLY /* FSE_optimalTableLog_internal */ #include "fse.h" /* header compression */ #define HUF_STATIC_LINKING_ONLY #include "huf.h" #include "error_private.h" /* ************************************************************** * Error Management ****************************************************************/ #define HUF_isError ERR_isError #define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ #define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e #define CHECK_F(f) { CHECK_V_F(_var_err__, f); } /* ************************************************************** * Utils ****************************************************************/ unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue) { return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 1); } /* ******************************************************* * HUF : Huffman block compression *********************************************************/ /* HUF_compressWeights() : * Same as FSE_compress(), but dedicated to huff0's weights compression. * The use case needs much less stack memory. * Note : all elements within weightTable are supposed to be <= HUF_TABLELOG_MAX. */ #define MAX_FSE_TABLELOG_FOR_HUFF_HEADER 6 size_t HUF_compressWeights (void* dst, size_t dstSize, const void* weightTable, size_t wtSize) { BYTE* const ostart = (BYTE*) dst; BYTE* op = ostart; BYTE* const oend = ostart + dstSize; U32 maxSymbolValue = HUF_TABLELOG_MAX; U32 tableLog = MAX_FSE_TABLELOG_FOR_HUFF_HEADER; FSE_CTable CTable[FSE_CTABLE_SIZE_U32(MAX_FSE_TABLELOG_FOR_HUFF_HEADER, HUF_TABLELOG_MAX)]; BYTE scratchBuffer[1< not compressible */ } tableLog = FSE_optimalTableLog(tableLog, wtSize, maxSymbolValue); CHECK_F( FSE_normalizeCount(norm, tableLog, count, wtSize, maxSymbolValue) ); /* Write table description header */ { CHECK_V_F(hSize, FSE_writeNCount(op, oend-op, norm, maxSymbolValue, tableLog) ); op += hSize; } /* Compress */ CHECK_F( FSE_buildCTable_wksp(CTable, norm, maxSymbolValue, tableLog, scratchBuffer, sizeof(scratchBuffer)) ); { CHECK_V_F(cSize, FSE_compress_usingCTable(op, oend - op, weightTable, wtSize, CTable) ); if (cSize == 0) return 0; /* not enough space for compressed data */ op += cSize; } return op-ostart; } struct HUF_CElt_s { U16 val; BYTE nbBits; }; /* typedef'd to HUF_CElt within "huf.h" */ /*! HUF_writeCTable() : `CTable` : Huffman tree to save, using huf representation. @return : size of saved CTable */ size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, U32 maxSymbolValue, U32 huffLog) { BYTE bitsToWeight[HUF_TABLELOG_MAX + 1]; /* precomputed conversion table */ BYTE huffWeight[HUF_SYMBOLVALUE_MAX]; BYTE* op = (BYTE*)dst; U32 n; /* check conditions */ if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge); /* convert to weight */ bitsToWeight[0] = 0; for (n=1; n1) & (hSize < maxSymbolValue/2)) { /* FSE compressed */ op[0] = (BYTE)hSize; return hSize+1; } } /* write raw values as 4-bits (max : 15) */ if (maxSymbolValue > (256-128)) return ERROR(GENERIC); /* should not happen : likely means source cannot be compressed */ if (((maxSymbolValue+1)/2) + 1 > maxDstSize) return ERROR(dstSize_tooSmall); /* not enough space within dst buffer */ op[0] = (BYTE)(128 /*special case*/ + (maxSymbolValue-1)); huffWeight[maxSymbolValue] = 0; /* to be sure it doesn't cause msan issue in final combination */ for (n=0; n HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge); if (nbSymbols > *maxSymbolValuePtr+1) return ERROR(maxSymbolValue_tooSmall); /* Prepare base value per rank */ { U32 n, nextRankStart = 0; for (n=1; n<=tableLog; n++) { U32 current = nextRankStart; nextRankStart += (rankVal[n] << (n-1)); rankVal[n] = current; } } /* fill nbBits */ { U32 n; for (n=0; nn=tableLog+1 */ U16 valPerRank[HUF_TABLELOG_MAX+2] = {0}; { U32 n; for (n=0; n0; n--) { /* start at n=tablelog <-> w=1 */ valPerRank[n] = min; /* get starting value within each rank */ min += nbPerRank[n]; min >>= 1; } } /* assign value within rank, symbol order */ { U32 n; for (n=0; n maxNbBits */ /* there are several too large elements (at least >= 2) */ { int totalCost = 0; const U32 baseCost = 1 << (largestBits - maxNbBits); U32 n = lastNonNull; while (huffNode[n].nbBits > maxNbBits) { totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits)); huffNode[n].nbBits = (BYTE)maxNbBits; n --; } /* n stops at huffNode[n].nbBits <= maxNbBits */ while (huffNode[n].nbBits == maxNbBits) n--; /* n end at index of smallest symbol using < maxNbBits */ /* renorm totalCost */ totalCost >>= (largestBits - maxNbBits); /* note : totalCost is necessarily a multiple of baseCost */ /* repay normalized cost */ { U32 const noSymbol = 0xF0F0F0F0; U32 rankLast[HUF_TABLELOG_MAX+2]; int pos; /* Get pos of last (smallest) symbol per rank */ memset(rankLast, 0xF0, sizeof(rankLast)); { U32 currentNbBits = maxNbBits; for (pos=n ; pos >= 0; pos--) { if (huffNode[pos].nbBits >= currentNbBits) continue; currentNbBits = huffNode[pos].nbBits; /* < maxNbBits */ rankLast[maxNbBits-currentNbBits] = pos; } } while (totalCost > 0) { U32 nBitsToDecrease = BIT_highbit32(totalCost) + 1; for ( ; nBitsToDecrease > 1; nBitsToDecrease--) { U32 highPos = rankLast[nBitsToDecrease]; U32 lowPos = rankLast[nBitsToDecrease-1]; if (highPos == noSymbol) continue; if (lowPos == noSymbol) break; { U32 const highTotal = huffNode[highPos].count; U32 const lowTotal = 2 * huffNode[lowPos].count; if (highTotal <= lowTotal) break; } } /* only triggered when no more rank 1 symbol left => find closest one (note : there is necessarily at least one !) */ /* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */ while ((nBitsToDecrease<=HUF_TABLELOG_MAX) && (rankLast[nBitsToDecrease] == noSymbol)) nBitsToDecrease ++; totalCost -= 1 << (nBitsToDecrease-1); if (rankLast[nBitsToDecrease-1] == noSymbol) rankLast[nBitsToDecrease-1] = rankLast[nBitsToDecrease]; /* this rank is no longer empty */ huffNode[rankLast[nBitsToDecrease]].nbBits ++; if (rankLast[nBitsToDecrease] == 0) /* special case, reached largest symbol */ rankLast[nBitsToDecrease] = noSymbol; else { rankLast[nBitsToDecrease]--; if (huffNode[rankLast[nBitsToDecrease]].nbBits != maxNbBits-nBitsToDecrease) rankLast[nBitsToDecrease] = noSymbol; /* this rank is now empty */ } } /* while (totalCost > 0) */ while (totalCost < 0) { /* Sometimes, cost correction overshoot */ if (rankLast[1] == noSymbol) { /* special case : no rank 1 symbol (using maxNbBits-1); let's create one from largest rank 0 (using maxNbBits) */ while (huffNode[n].nbBits == maxNbBits) n--; huffNode[n+1].nbBits--; rankLast[1] = n+1; totalCost++; continue; } huffNode[ rankLast[1] + 1 ].nbBits--; rankLast[1]++; totalCost ++; } } } /* there are several too large elements (at least >= 2) */ return maxNbBits; } typedef struct { U32 base; U32 current; } rankPos; static void HUF_sort(nodeElt* huffNode, const U32* count, U32 maxSymbolValue) { rankPos rank[32]; U32 n; memset(rank, 0, sizeof(rank)); for (n=0; n<=maxSymbolValue; n++) { U32 r = BIT_highbit32(count[n] + 1); rank[r].base ++; } for (n=30; n>0; n--) rank[n-1].base += rank[n].base; for (n=0; n<32; n++) rank[n].current = rank[n].base; for (n=0; n<=maxSymbolValue; n++) { U32 const c = count[n]; U32 const r = BIT_highbit32(c+1) + 1; U32 pos = rank[r].current++; while ((pos > rank[r].base) && (c > huffNode[pos-1].count)) { huffNode[pos] = huffNode[pos-1]; pos--; } huffNode[pos].count = c; huffNode[pos].byte = (BYTE)n; } } /** HUF_buildCTable_wksp() : * Same as HUF_buildCTable(), but using externally allocated scratch buffer. * `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as a table of HUF_CTABLE_WORKSPACE_SIZE_U32 unsigned. */ #define STARTNODE (HUF_SYMBOLVALUE_MAX+1) typedef nodeElt huffNodeTable[HUF_CTABLE_WORKSPACE_SIZE_U32]; size_t HUF_buildCTable_wksp (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32 maxNbBits, void* workSpace, size_t wkspSize) { nodeElt* const huffNode0 = (nodeElt*)workSpace; nodeElt* const huffNode = huffNode0+1; U32 n, nonNullRank; int lowS, lowN; U16 nodeNb = STARTNODE; U32 nodeRoot; /* safety checks */ if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC); /* must be aligned on 4-bytes boundaries */ if (wkspSize < sizeof(huffNodeTable)) return ERROR(workSpace_tooSmall); if (maxNbBits == 0) maxNbBits = HUF_TABLELOG_DEFAULT; if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge); memset(huffNode0, 0, sizeof(huffNodeTable)); /* sort, decreasing order */ HUF_sort(huffNode, count, maxSymbolValue); /* init for parents */ nonNullRank = maxSymbolValue; while(huffNode[nonNullRank].count == 0) nonNullRank--; lowS = nonNullRank; nodeRoot = nodeNb + lowS - 1; lowN = nodeNb; huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS-1].count; huffNode[lowS].parent = huffNode[lowS-1].parent = nodeNb; nodeNb++; lowS-=2; for (n=nodeNb; n<=nodeRoot; n++) huffNode[n].count = (U32)(1U<<30); huffNode0[0].count = (U32)(1U<<31); /* fake entry, strong barrier */ /* create parents */ while (nodeNb <= nodeRoot) { U32 n1 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++; U32 n2 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++; huffNode[nodeNb].count = huffNode[n1].count + huffNode[n2].count; huffNode[n1].parent = huffNode[n2].parent = nodeNb; nodeNb++; } /* distribute weights (unlimited tree height) */ huffNode[nodeRoot].nbBits = 0; for (n=nodeRoot-1; n>=STARTNODE; n--) huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1; for (n=0; n<=nonNullRank; n++) huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1; /* enforce maxTableLog */ maxNbBits = HUF_setMaxHeight(huffNode, nonNullRank, maxNbBits); /* fill result into tree (val, nbBits) */ { U16 nbPerRank[HUF_TABLELOG_MAX+1] = {0}; U16 valPerRank[HUF_TABLELOG_MAX+1] = {0}; if (maxNbBits > HUF_TABLELOG_MAX) return ERROR(GENERIC); /* check fit into table */ for (n=0; n<=nonNullRank; n++) nbPerRank[huffNode[n].nbBits]++; /* determine stating value per rank */ { U16 min = 0; for (n=maxNbBits; n>0; n--) { valPerRank[n] = min; /* get starting value within each rank */ min += nbPerRank[n]; min >>= 1; } } for (n=0; n<=maxSymbolValue; n++) tree[huffNode[n].byte].nbBits = huffNode[n].nbBits; /* push nbBits per symbol, symbol order */ for (n=0; n<=maxSymbolValue; n++) tree[n].val = valPerRank[tree[n].nbBits]++; /* assign value within rank, symbol order */ } return maxNbBits; } /** HUF_buildCTable() : * @return : maxNbBits * Note : count is used before tree is written, so they can safely overlap */ size_t HUF_buildCTable (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32 maxNbBits) { huffNodeTable nodeTable; return HUF_buildCTable_wksp(tree, count, maxSymbolValue, maxNbBits, nodeTable, sizeof(nodeTable)); } static size_t HUF_estimateCompressedSize(HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue) { size_t nbBits = 0; int s; for (s = 0; s <= (int)maxSymbolValue; ++s) { nbBits += CTable[s].nbBits * count[s]; } return nbBits >> 3; } static int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue) { int bad = 0; int s; for (s = 0; s <= (int)maxSymbolValue; ++s) { bad |= (count[s] != 0) & (CTable[s].nbBits == 0); } return !bad; } size_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); } FORCE_INLINE_TEMPLATE void HUF_encodeSymbol(BIT_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable) { BIT_addBitsFast(bitCPtr, CTable[symbol].val, CTable[symbol].nbBits); } #define HUF_FLUSHBITS(s) BIT_flushBits(s) #define HUF_FLUSHBITS_1(stream) \ if (sizeof((stream)->bitContainer)*8 < HUF_TABLELOG_MAX*2+7) HUF_FLUSHBITS(stream) #define HUF_FLUSHBITS_2(stream) \ if (sizeof((stream)->bitContainer)*8 < HUF_TABLELOG_MAX*4+7) HUF_FLUSHBITS(stream) FORCE_INLINE_TEMPLATE size_t HUF_compress1X_usingCTable_internal_body(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable) { const BYTE* ip = (const BYTE*) src; BYTE* const ostart = (BYTE*)dst; BYTE* const oend = ostart + dstSize; BYTE* op = ostart; size_t n; BIT_CStream_t bitC; /* init */ if (dstSize < 8) return 0; /* not enough space to compress */ { size_t const initErr = BIT_initCStream(&bitC, op, oend-op); if (HUF_isError(initErr)) return 0; } n = srcSize & ~3; /* join to mod 4 */ switch (srcSize & 3) { case 3 : HUF_encodeSymbol(&bitC, ip[n+ 2], CTable); HUF_FLUSHBITS_2(&bitC); /* fall-through */ case 2 : HUF_encodeSymbol(&bitC, ip[n+ 1], CTable); HUF_FLUSHBITS_1(&bitC); /* fall-through */ case 1 : HUF_encodeSymbol(&bitC, ip[n+ 0], CTable); HUF_FLUSHBITS(&bitC); /* fall-through */ case 0 : /* fall-through */ default: break; } for (; n>0; n-=4) { /* note : n&3==0 at this stage */ HUF_encodeSymbol(&bitC, ip[n- 1], CTable); HUF_FLUSHBITS_1(&bitC); HUF_encodeSymbol(&bitC, ip[n- 2], CTable); HUF_FLUSHBITS_2(&bitC); HUF_encodeSymbol(&bitC, ip[n- 3], CTable); HUF_FLUSHBITS_1(&bitC); HUF_encodeSymbol(&bitC, ip[n- 4], CTable); HUF_FLUSHBITS(&bitC); } return BIT_closeCStream(&bitC); } #if DYNAMIC_BMI2 static TARGET_ATTRIBUTE("bmi2") size_t HUF_compress1X_usingCTable_internal_bmi2(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable) { return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable); } static size_t HUF_compress1X_usingCTable_internal_default(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable) { return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable); } static size_t HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, const int bmi2) { if (bmi2) { return HUF_compress1X_usingCTable_internal_bmi2(dst, dstSize, src, srcSize, CTable); } return HUF_compress1X_usingCTable_internal_default(dst, dstSize, src, srcSize, CTable); } #else static size_t HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, const int bmi2) { (void)bmi2; return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable); } #endif size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable) { return HUF_compress1X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, /* bmi2 */ 0); } static size_t HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int bmi2) { size_t const segmentSize = (srcSize+3)/4; /* first 3 segments */ const BYTE* ip = (const BYTE*) src; const BYTE* const iend = ip + srcSize; BYTE* const ostart = (BYTE*) dst; BYTE* const oend = ostart + dstSize; BYTE* op = ostart; if (dstSize < 6 + 1 + 1 + 1 + 8) return 0; /* minimum space to compress successfully */ if (srcSize < 12) return 0; /* no saving possible : too small input */ op += 6; /* jumpTable */ { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, segmentSize, CTable, bmi2) ); if (cSize==0) return 0; assert(cSize <= 65535); MEM_writeLE16(ostart, (U16)cSize); op += cSize; } ip += segmentSize; { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, segmentSize, CTable, bmi2) ); if (cSize==0) return 0; assert(cSize <= 65535); MEM_writeLE16(ostart+2, (U16)cSize); op += cSize; } ip += segmentSize; { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, segmentSize, CTable, bmi2) ); if (cSize==0) return 0; assert(cSize <= 65535); MEM_writeLE16(ostart+4, (U16)cSize); op += cSize; } ip += segmentSize; { CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, oend-op, ip, iend-ip, CTable, bmi2) ); if (cSize==0) return 0; op += cSize; } return op-ostart; } size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable) { return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, /* bmi2 */ 0); } static size_t HUF_compressCTable_internal( BYTE* const ostart, BYTE* op, BYTE* const oend, const void* src, size_t srcSize, unsigned singleStream, const HUF_CElt* CTable, const int bmi2) { size_t const cSize = singleStream ? HUF_compress1X_usingCTable_internal(op, oend - op, src, srcSize, CTable, bmi2) : HUF_compress4X_usingCTable_internal(op, oend - op, src, srcSize, CTable, bmi2); if (HUF_isError(cSize)) { return cSize; } if (cSize==0) { return 0; } /* uncompressible */ op += cSize; /* check compressibility */ if ((size_t)(op-ostart) >= srcSize-1) { return 0; } return op-ostart; } typedef struct { U32 count[HUF_SYMBOLVALUE_MAX + 1]; HUF_CElt CTable[HUF_SYMBOLVALUE_MAX + 1]; huffNodeTable nodeTable; } HUF_compress_tables_t; /* HUF_compress_internal() : * `workSpace` must a table of at least HUF_WORKSPACE_SIZE_U32 unsigned */ static size_t HUF_compress_internal ( void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog, unsigned singleStream, void* workSpace, size_t wkspSize, HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat, const int bmi2) { HUF_compress_tables_t* const table = (HUF_compress_tables_t*)workSpace; BYTE* const ostart = (BYTE*)dst; BYTE* const oend = ostart + dstSize; BYTE* op = ostart; /* checks & inits */ if (((size_t)workSpace & 3) != 0) return ERROR(GENERIC); /* must be aligned on 4-bytes boundaries */ if (wkspSize < sizeof(*table)) return ERROR(workSpace_tooSmall); if (!srcSize) return 0; /* Uncompressed */ if (!dstSize) return 0; /* cannot fit anything within dst budget */ if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong); /* current block size limit */ if (huffLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge); if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge); if (!maxSymbolValue) maxSymbolValue = HUF_SYMBOLVALUE_MAX; if (!huffLog) huffLog = HUF_TABLELOG_DEFAULT; /* Heuristic : If old table is valid, use it for small inputs */ if (preferRepeat && repeat && *repeat == HUF_repeat_valid) { return HUF_compressCTable_internal(ostart, op, oend, src, srcSize, singleStream, oldHufTable, bmi2); } /* Scan input and build symbol stats */ { CHECK_V_F(largest, FSE_count_wksp (table->count, &maxSymbolValue, (const BYTE*)src, srcSize, table->count) ); if (largest == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; } /* single symbol, rle */ if (largest <= (srcSize >> 7)+1) return 0; /* heuristic : probably not compressible enough */ } /* Check validity of previous table */ if ( repeat && *repeat == HUF_repeat_check && !HUF_validateCTable(oldHufTable, table->count, maxSymbolValue)) { *repeat = HUF_repeat_none; } /* Heuristic : use existing table for small inputs */ if (preferRepeat && repeat && *repeat != HUF_repeat_none) { return HUF_compressCTable_internal(ostart, op, oend, src, srcSize, singleStream, oldHufTable, bmi2); } /* Build Huffman Tree */ huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue); { CHECK_V_F(maxBits, HUF_buildCTable_wksp(table->CTable, table->count, maxSymbolValue, huffLog, table->nodeTable, sizeof(table->nodeTable)) ); huffLog = (U32)maxBits; /* Zero unused symbols in CTable, so we can check it for validity */ memset(table->CTable + (maxSymbolValue + 1), 0, sizeof(table->CTable) - ((maxSymbolValue + 1) * sizeof(HUF_CElt))); } /* Write table description header */ { CHECK_V_F(hSize, HUF_writeCTable (op, dstSize, table->CTable, maxSymbolValue, huffLog) ); /* Check if using previous huffman table is beneficial */ if (repeat && *repeat != HUF_repeat_none) { size_t const oldSize = HUF_estimateCompressedSize(oldHufTable, table->count, maxSymbolValue); size_t const newSize = HUF_estimateCompressedSize(table->CTable, table->count, maxSymbolValue); if (oldSize <= hSize + newSize || hSize + 12 >= srcSize) { return HUF_compressCTable_internal(ostart, op, oend, src, srcSize, singleStream, oldHufTable, bmi2); } } /* Use the new huffman table */ if (hSize + 12ul >= srcSize) { return 0; } op += hSize; if (repeat) { *repeat = HUF_repeat_none; } if (oldHufTable) memcpy(oldHufTable, table->CTable, sizeof(table->CTable)); /* Save new table */ } return HUF_compressCTable_internal(ostart, op, oend, src, srcSize, singleStream, table->CTable, bmi2); } size_t HUF_compress1X_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog, void* workSpace, size_t wkspSize) { return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 1 /*single stream*/, workSpace, wkspSize, NULL, NULL, 0, 0 /*bmi2*/); } size_t HUF_compress1X_repeat (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog, void* workSpace, size_t wkspSize, HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2) { return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 1 /*single stream*/, workSpace, wkspSize, hufTable, repeat, preferRepeat, bmi2); } size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog) { unsigned workSpace[HUF_WORKSPACE_SIZE_U32]; return HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace)); } /* HUF_compress4X_repeat(): * compress input using 4 streams. * provide workspace to generate compression tables */ size_t HUF_compress4X_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog, void* workSpace, size_t wkspSize) { return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 0 /*4 streams*/, workSpace, wkspSize, NULL, NULL, 0, 0 /*bmi2*/); } /* HUF_compress4X_repeat(): * compress input using 4 streams. * re-use an existing huffman compression table */ size_t HUF_compress4X_repeat (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog, void* workSpace, size_t wkspSize, HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2) { return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 0 /* 4 streams */, workSpace, wkspSize, hufTable, repeat, preferRepeat, bmi2); } size_t HUF_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned huffLog) { unsigned workSpace[HUF_WORKSPACE_SIZE_U32]; return HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace)); } size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize) { return HUF_compress2(dst, maxDstSize, src, srcSize, 255, HUF_TABLELOG_DEFAULT); } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/huf_decompress.c ================================================ /* ****************************************************************** Huffman decoder, part of New Generation Entropy library Copyright (C) 2013-2016, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c ****************************************************************** */ /* ************************************************************** * Dependencies ****************************************************************/ #include /* memcpy, memset */ #include "bitstream.h" /* BIT_* */ #include "compiler.h" #include "fse.h" /* header compression */ #define HUF_STATIC_LINKING_ONLY #include "huf.h" #include "error_private.h" /* ************************************************************** * Error Management ****************************************************************/ #define HUF_isError ERR_isError #define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ #define CHECK_F(f) { size_t const err_ = (f); if (HUF_isError(err_)) return err_; } /* ************************************************************** * Byte alignment for workSpace management ****************************************************************/ #define HUF_ALIGN(x, a) HUF_ALIGN_MASK((x), (a) - 1) #define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask)) /*-***************************/ /* generic DTableDesc */ /*-***************************/ typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc; static DTableDesc HUF_getDTableDesc(const HUF_DTable* table) { DTableDesc dtd; memcpy(&dtd, table, sizeof(dtd)); return dtd; } /*-***************************/ /* single-symbol decoding */ /*-***************************/ typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2; /* single-symbol decoding */ size_t HUF_readDTableX2_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize) { U32 tableLog = 0; U32 nbSymbols = 0; size_t iSize; void* const dtPtr = DTable + 1; HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr; U32* rankVal; BYTE* huffWeight; size_t spaceUsed32 = 0; rankVal = (U32 *)workSpace + spaceUsed32; spaceUsed32 += HUF_TABLELOG_ABSOLUTEMAX + 1; huffWeight = (BYTE *)((U32 *)workSpace + spaceUsed32); spaceUsed32 += HUF_ALIGN(HUF_SYMBOLVALUE_MAX + 1, sizeof(U32)) >> 2; if ((spaceUsed32 << 2) > wkspSize) return ERROR(tableLog_tooLarge); HUF_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUF_DTable)); /* memset(huffWeight, 0, sizeof(huffWeight)); */ /* is not necessary, even though some analyzer complain ... */ iSize = HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize); if (HUF_isError(iSize)) return iSize; /* Table header */ { DTableDesc dtd = HUF_getDTableDesc(DTable); if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge); /* DTable too small, Huffman tree cannot fit in */ dtd.tableType = 0; dtd.tableLog = (BYTE)tableLog; memcpy(DTable, &dtd, sizeof(dtd)); } /* Calculate starting value for each rank */ { U32 n, nextRankStart = 0; for (n=1; n> 1; U32 u; HUF_DEltX2 D; D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w); for (u = rankVal[w]; u < rankVal[w] + length; u++) dt[u] = D; rankVal[w] += length; } } return iSize; } size_t HUF_readDTableX2(HUF_DTable* DTable, const void* src, size_t srcSize) { U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; return HUF_readDTableX2_wksp(DTable, src, srcSize, workSpace, sizeof(workSpace)); } typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4; /* double-symbols decoding */ FORCE_INLINE_TEMPLATE BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog) { size_t const val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ BYTE const c = dt[val].byte; BIT_skipBits(Dstream, dt[val].nbBits); return c; } #define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \ *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog) #define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \ if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \ HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) #define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \ if (MEM_64bits()) \ HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) HINT_INLINE size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog) { BYTE* const pStart = p; /* up to 4 symbols at a time */ while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-3)) { HUF_DECODE_SYMBOLX2_2(p, bitDPtr); HUF_DECODE_SYMBOLX2_1(p, bitDPtr); HUF_DECODE_SYMBOLX2_2(p, bitDPtr); HUF_DECODE_SYMBOLX2_0(p, bitDPtr); } /* [0-3] symbols remaining */ if (MEM_32bits()) while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd)) HUF_DECODE_SYMBOLX2_0(p, bitDPtr); /* no more data to retrieve from bitstream, no need to reload */ while (p < pEnd) HUF_DECODE_SYMBOLX2_0(p, bitDPtr); return pEnd-pStart; } FORCE_INLINE_TEMPLATE size_t HUF_decompress1X2_usingDTable_internal_body( void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable) { BYTE* op = (BYTE*)dst; BYTE* const oend = op + dstSize; const void* dtPtr = DTable + 1; const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr; BIT_DStream_t bitD; DTableDesc const dtd = HUF_getDTableDesc(DTable); U32 const dtLog = dtd.tableLog; CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) ); HUF_decodeStreamX2(op, &bitD, oend, dt, dtLog); if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected); return dstSize; } FORCE_INLINE_TEMPLATE size_t HUF_decompress4X2_usingDTable_internal_body( void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable) { /* Check */ if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */ { const BYTE* const istart = (const BYTE*) cSrc; BYTE* const ostart = (BYTE*) dst; BYTE* const oend = ostart + dstSize; const void* const dtPtr = DTable + 1; const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr; /* Init */ BIT_DStream_t bitD1; BIT_DStream_t bitD2; BIT_DStream_t bitD3; BIT_DStream_t bitD4; size_t const length1 = MEM_readLE16(istart); size_t const length2 = MEM_readLE16(istart+2); size_t const length3 = MEM_readLE16(istart+4); size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6); const BYTE* const istart1 = istart + 6; /* jumpTable */ const BYTE* const istart2 = istart1 + length1; const BYTE* const istart3 = istart2 + length2; const BYTE* const istart4 = istart3 + length3; const size_t segmentSize = (dstSize+3) / 4; BYTE* const opStart2 = ostart + segmentSize; BYTE* const opStart3 = opStart2 + segmentSize; BYTE* const opStart4 = opStart3 + segmentSize; BYTE* op1 = ostart; BYTE* op2 = opStart2; BYTE* op3 = opStart3; BYTE* op4 = opStart4; U32 endSignal = BIT_DStream_unfinished; DTableDesc const dtd = HUF_getDTableDesc(DTable); U32 const dtLog = dtd.tableLog; if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */ CHECK_F( BIT_initDStream(&bitD1, istart1, length1) ); CHECK_F( BIT_initDStream(&bitD2, istart2, length2) ); CHECK_F( BIT_initDStream(&bitD3, istart3, length3) ); CHECK_F( BIT_initDStream(&bitD4, istart4, length4) ); /* up to 16 symbols per loop (4 symbols per stream) in 64-bit mode */ endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); while ( (endSignal==BIT_DStream_unfinished) && (op4<(oend-3)) ) { HUF_DECODE_SYMBOLX2_2(op1, &bitD1); HUF_DECODE_SYMBOLX2_2(op2, &bitD2); HUF_DECODE_SYMBOLX2_2(op3, &bitD3); HUF_DECODE_SYMBOLX2_2(op4, &bitD4); HUF_DECODE_SYMBOLX2_1(op1, &bitD1); HUF_DECODE_SYMBOLX2_1(op2, &bitD2); HUF_DECODE_SYMBOLX2_1(op3, &bitD3); HUF_DECODE_SYMBOLX2_1(op4, &bitD4); HUF_DECODE_SYMBOLX2_2(op1, &bitD1); HUF_DECODE_SYMBOLX2_2(op2, &bitD2); HUF_DECODE_SYMBOLX2_2(op3, &bitD3); HUF_DECODE_SYMBOLX2_2(op4, &bitD4); HUF_DECODE_SYMBOLX2_0(op1, &bitD1); HUF_DECODE_SYMBOLX2_0(op2, &bitD2); HUF_DECODE_SYMBOLX2_0(op3, &bitD3); HUF_DECODE_SYMBOLX2_0(op4, &bitD4); BIT_reloadDStream(&bitD1); BIT_reloadDStream(&bitD2); BIT_reloadDStream(&bitD3); BIT_reloadDStream(&bitD4); } /* check corruption */ /* note : should not be necessary : op# advance in lock step, and we control op4. * but curiously, binary generated by gcc 7.2 & 7.3 with -mbmi2 runs faster when >=1 test is present */ if (op1 > opStart2) return ERROR(corruption_detected); if (op2 > opStart3) return ERROR(corruption_detected); if (op3 > opStart4) return ERROR(corruption_detected); /* note : op4 supposed already verified within main loop */ /* finish bitStreams one by one */ HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog); HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog); HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog); HUF_decodeStreamX2(op4, &bitD4, oend, dt, dtLog); /* check */ { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); if (!endCheck) return ERROR(corruption_detected); } /* decoded size */ return dstSize; } } FORCE_INLINE_TEMPLATE U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog) { size_t const val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */ memcpy(op, dt+val, 2); BIT_skipBits(DStream, dt[val].nbBits); return dt[val].length; } FORCE_INLINE_TEMPLATE U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog) { size_t const val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */ memcpy(op, dt+val, 1); if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits); else { if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) { BIT_skipBits(DStream, dt[val].nbBits); if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8)) /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */ DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8); } } return 1; } #define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \ ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) #define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \ if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \ ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) #define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \ if (MEM_64bits()) \ ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) HINT_INLINE size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog) { BYTE* const pStart = p; /* up to 8 symbols at a time */ while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-(sizeof(bitDPtr->bitContainer)-1))) { HUF_DECODE_SYMBOLX4_2(p, bitDPtr); HUF_DECODE_SYMBOLX4_1(p, bitDPtr); HUF_DECODE_SYMBOLX4_2(p, bitDPtr); HUF_DECODE_SYMBOLX4_0(p, bitDPtr); } /* closer to end : up to 2 symbols at a time */ while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p <= pEnd-2)) HUF_DECODE_SYMBOLX4_0(p, bitDPtr); while (p <= pEnd-2) HUF_DECODE_SYMBOLX4_0(p, bitDPtr); /* no need to reload : reached the end of DStream */ if (p < pEnd) p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog); return p-pStart; } FORCE_INLINE_TEMPLATE size_t HUF_decompress1X4_usingDTable_internal_body( void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable) { BIT_DStream_t bitD; /* Init */ CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) ); /* decode */ { BYTE* const ostart = (BYTE*) dst; BYTE* const oend = ostart + dstSize; const void* const dtPtr = DTable+1; /* force compiler to not use strict-aliasing */ const HUF_DEltX4* const dt = (const HUF_DEltX4*)dtPtr; DTableDesc const dtd = HUF_getDTableDesc(DTable); HUF_decodeStreamX4(ostart, &bitD, oend, dt, dtd.tableLog); } /* check */ if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected); /* decoded size */ return dstSize; } FORCE_INLINE_TEMPLATE size_t HUF_decompress4X4_usingDTable_internal_body( void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable) { if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */ { const BYTE* const istart = (const BYTE*) cSrc; BYTE* const ostart = (BYTE*) dst; BYTE* const oend = ostart + dstSize; const void* const dtPtr = DTable+1; const HUF_DEltX4* const dt = (const HUF_DEltX4*)dtPtr; /* Init */ BIT_DStream_t bitD1; BIT_DStream_t bitD2; BIT_DStream_t bitD3; BIT_DStream_t bitD4; size_t const length1 = MEM_readLE16(istart); size_t const length2 = MEM_readLE16(istart+2); size_t const length3 = MEM_readLE16(istart+4); size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6); const BYTE* const istart1 = istart + 6; /* jumpTable */ const BYTE* const istart2 = istart1 + length1; const BYTE* const istart3 = istart2 + length2; const BYTE* const istart4 = istart3 + length3; size_t const segmentSize = (dstSize+3) / 4; BYTE* const opStart2 = ostart + segmentSize; BYTE* const opStart3 = opStart2 + segmentSize; BYTE* const opStart4 = opStart3 + segmentSize; BYTE* op1 = ostart; BYTE* op2 = opStart2; BYTE* op3 = opStart3; BYTE* op4 = opStart4; U32 endSignal; DTableDesc const dtd = HUF_getDTableDesc(DTable); U32 const dtLog = dtd.tableLog; if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */ CHECK_F( BIT_initDStream(&bitD1, istart1, length1) ); CHECK_F( BIT_initDStream(&bitD2, istart2, length2) ); CHECK_F( BIT_initDStream(&bitD3, istart3, length3) ); CHECK_F( BIT_initDStream(&bitD4, istart4, length4) ); /* 16-32 symbols per loop (4-8 symbols per stream) */ endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); for ( ; (endSignal==BIT_DStream_unfinished) & (op4<(oend-(sizeof(bitD4.bitContainer)-1))) ; ) { HUF_DECODE_SYMBOLX4_2(op1, &bitD1); HUF_DECODE_SYMBOLX4_2(op2, &bitD2); HUF_DECODE_SYMBOLX4_2(op3, &bitD3); HUF_DECODE_SYMBOLX4_2(op4, &bitD4); HUF_DECODE_SYMBOLX4_1(op1, &bitD1); HUF_DECODE_SYMBOLX4_1(op2, &bitD2); HUF_DECODE_SYMBOLX4_1(op3, &bitD3); HUF_DECODE_SYMBOLX4_1(op4, &bitD4); HUF_DECODE_SYMBOLX4_2(op1, &bitD1); HUF_DECODE_SYMBOLX4_2(op2, &bitD2); HUF_DECODE_SYMBOLX4_2(op3, &bitD3); HUF_DECODE_SYMBOLX4_2(op4, &bitD4); HUF_DECODE_SYMBOLX4_0(op1, &bitD1); HUF_DECODE_SYMBOLX4_0(op2, &bitD2); HUF_DECODE_SYMBOLX4_0(op3, &bitD3); HUF_DECODE_SYMBOLX4_0(op4, &bitD4); endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); } /* check corruption */ if (op1 > opStart2) return ERROR(corruption_detected); if (op2 > opStart3) return ERROR(corruption_detected); if (op3 > opStart4) return ERROR(corruption_detected); /* note : op4 already verified within main loop */ /* finish bitStreams one by one */ HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog); HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog); HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog); HUF_decodeStreamX4(op4, &bitD4, oend, dt, dtLog); /* check */ { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); if (!endCheck) return ERROR(corruption_detected); } /* decoded size */ return dstSize; } } typedef size_t (*HUF_decompress_usingDTable_t)(void *dst, size_t dstSize, const void *cSrc, size_t cSrcSize, const HUF_DTable *DTable); #if DYNAMIC_BMI2 #define X(fn) \ \ static size_t fn##_default( \ void* dst, size_t dstSize, \ const void* cSrc, size_t cSrcSize, \ const HUF_DTable* DTable) \ { \ return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \ } \ \ static TARGET_ATTRIBUTE("bmi2") size_t fn##_bmi2( \ void* dst, size_t dstSize, \ const void* cSrc, size_t cSrcSize, \ const HUF_DTable* DTable) \ { \ return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \ } \ \ static size_t fn(void* dst, size_t dstSize, void const* cSrc, \ size_t cSrcSize, HUF_DTable const* DTable, int bmi2) \ { \ if (bmi2) { \ return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable); \ } \ return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable); \ } #else #define X(fn) \ static size_t fn(void* dst, size_t dstSize, void const* cSrc, \ size_t cSrcSize, HUF_DTable const* DTable, int bmi2) \ { \ (void)bmi2; \ return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \ } #endif X(HUF_decompress1X2_usingDTable_internal) X(HUF_decompress4X2_usingDTable_internal) X(HUF_decompress1X4_usingDTable_internal) X(HUF_decompress4X4_usingDTable_internal) #undef X size_t HUF_decompress1X2_usingDTable( void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable) { DTableDesc dtd = HUF_getDTableDesc(DTable); if (dtd.tableType != 0) return ERROR(GENERIC); return HUF_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); } size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize) { const BYTE* ip = (const BYTE*) cSrc; size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize, workSpace, wkspSize); if (HUF_isError(hSize)) return hSize; if (hSize >= cSrcSize) return ERROR(srcSize_wrong); ip += hSize; cSrcSize -= hSize; return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0); } size_t HUF_decompress1X2_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; return HUF_decompress1X2_DCtx_wksp(DCtx, dst, dstSize, cSrc, cSrcSize, workSpace, sizeof(workSpace)); } size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX); return HUF_decompress1X2_DCtx (DTable, dst, dstSize, cSrc, cSrcSize); } size_t HUF_decompress4X2_usingDTable( void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable) { DTableDesc dtd = HUF_getDTableDesc(DTable); if (dtd.tableType != 0) return ERROR(GENERIC); return HUF_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); } static size_t HUF_decompress4X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2) { const BYTE* ip = (const BYTE*) cSrc; size_t const hSize = HUF_readDTableX2_wksp (dctx, cSrc, cSrcSize, workSpace, wkspSize); if (HUF_isError(hSize)) return hSize; if (hSize >= cSrcSize) return ERROR(srcSize_wrong); ip += hSize; cSrcSize -= hSize; return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2); } size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize) { return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, 0); } size_t HUF_decompress4X2_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, sizeof(workSpace)); } size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_TABLELOG_MAX); return HUF_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize); } /* *************************/ /* double-symbols decoding */ /* *************************/ typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t; /* HUF_fillDTableX4Level2() : * `rankValOrigin` must be a table of at least (HUF_TABLELOG_MAX + 1) U32 */ static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed, const U32* rankValOrigin, const int minWeight, const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, U32 nbBitsBaseline, U16 baseSeq) { HUF_DEltX4 DElt; U32 rankVal[HUF_TABLELOG_MAX + 1]; /* get pre-calculated rankVal */ memcpy(rankVal, rankValOrigin, sizeof(rankVal)); /* fill skipped values */ if (minWeight>1) { U32 i, skipSize = rankVal[minWeight]; MEM_writeLE16(&(DElt.sequence), baseSeq); DElt.nbBits = (BYTE)(consumed); DElt.length = 1; for (i = 0; i < skipSize; i++) DTable[i] = DElt; } /* fill DTable */ { U32 s; for (s=0; s= 1 */ rankVal[weight] += length; } } } typedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1]; typedef rankValCol_t rankVal_t[HUF_TABLELOG_MAX]; static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog, const sortedSymbol_t* sortedList, const U32 sortedListSize, const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight, const U32 nbBitsBaseline) { U32 rankVal[HUF_TABLELOG_MAX + 1]; const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */ const U32 minBits = nbBitsBaseline - maxWeight; U32 s; memcpy(rankVal, rankValOrigin, sizeof(rankVal)); /* fill DTable */ for (s=0; s= minBits) { /* enough room for a second symbol */ U32 sortedRank; int minWeight = nbBits + scaleLog; if (minWeight < 1) minWeight = 1; sortedRank = rankStart[minWeight]; HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits, rankValOrigin[nbBits], minWeight, sortedList+sortedRank, sortedListSize-sortedRank, nbBitsBaseline, symbol); } else { HUF_DEltX4 DElt; MEM_writeLE16(&(DElt.sequence), symbol); DElt.nbBits = (BYTE)(nbBits); DElt.length = 1; { U32 const end = start + length; U32 u; for (u = start; u < end; u++) DTable[u] = DElt; } } rankVal[weight] += length; } } size_t HUF_readDTableX4_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize) { U32 tableLog, maxW, sizeOfSort, nbSymbols; DTableDesc dtd = HUF_getDTableDesc(DTable); U32 const maxTableLog = dtd.maxTableLog; size_t iSize; void* dtPtr = DTable+1; /* force compiler to avoid strict-aliasing */ HUF_DEltX4* const dt = (HUF_DEltX4*)dtPtr; U32 *rankStart; rankValCol_t* rankVal; U32* rankStats; U32* rankStart0; sortedSymbol_t* sortedSymbol; BYTE* weightList; size_t spaceUsed32 = 0; rankVal = (rankValCol_t *)((U32 *)workSpace + spaceUsed32); spaceUsed32 += (sizeof(rankValCol_t) * HUF_TABLELOG_MAX) >> 2; rankStats = (U32 *)workSpace + spaceUsed32; spaceUsed32 += HUF_TABLELOG_MAX + 1; rankStart0 = (U32 *)workSpace + spaceUsed32; spaceUsed32 += HUF_TABLELOG_MAX + 2; sortedSymbol = (sortedSymbol_t *)workSpace + (spaceUsed32 * sizeof(U32)) / sizeof(sortedSymbol_t); spaceUsed32 += HUF_ALIGN(sizeof(sortedSymbol_t) * (HUF_SYMBOLVALUE_MAX + 1), sizeof(U32)) >> 2; weightList = (BYTE *)((U32 *)workSpace + spaceUsed32); spaceUsed32 += HUF_ALIGN(HUF_SYMBOLVALUE_MAX + 1, sizeof(U32)) >> 2; if ((spaceUsed32 << 2) > wkspSize) return ERROR(tableLog_tooLarge); rankStart = rankStart0 + 1; memset(rankStats, 0, sizeof(U32) * (2 * HUF_TABLELOG_MAX + 2 + 1)); HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(HUF_DTable)); /* if compiler fails here, assertion is wrong */ if (maxTableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge); /* memset(weightList, 0, sizeof(weightList)); */ /* is not necessary, even though some analyzer complain ... */ iSize = HUF_readStats(weightList, HUF_SYMBOLVALUE_MAX + 1, rankStats, &nbSymbols, &tableLog, src, srcSize); if (HUF_isError(iSize)) return iSize; /* check result */ if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */ /* find maxWeight */ for (maxW = tableLog; rankStats[maxW]==0; maxW--) {} /* necessarily finds a solution before 0 */ /* Get start index of each weight */ { U32 w, nextRankStart = 0; for (w=1; w> consumed; } } } } HUF_fillDTableX4(dt, maxTableLog, sortedSymbol, sizeOfSort, rankStart0, rankVal, maxW, tableLog+1); dtd.tableLog = (BYTE)maxTableLog; dtd.tableType = 1; memcpy(DTable, &dtd, sizeof(dtd)); return iSize; } size_t HUF_readDTableX4(HUF_DTable* DTable, const void* src, size_t srcSize) { U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; return HUF_readDTableX4_wksp(DTable, src, srcSize, workSpace, sizeof(workSpace)); } size_t HUF_decompress1X4_usingDTable( void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable) { DTableDesc dtd = HUF_getDTableDesc(DTable); if (dtd.tableType != 1) return ERROR(GENERIC); return HUF_decompress1X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); } size_t HUF_decompress1X4_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize) { const BYTE* ip = (const BYTE*) cSrc; size_t const hSize = HUF_readDTableX4_wksp(DCtx, cSrc, cSrcSize, workSpace, wkspSize); if (HUF_isError(hSize)) return hSize; if (hSize >= cSrcSize) return ERROR(srcSize_wrong); ip += hSize; cSrcSize -= hSize; return HUF_decompress1X4_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0); } size_t HUF_decompress1X4_DCtx(HUF_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; return HUF_decompress1X4_DCtx_wksp(DCtx, dst, dstSize, cSrc, cSrcSize, workSpace, sizeof(workSpace)); } size_t HUF_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_TABLELOG_MAX); return HUF_decompress1X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize); } size_t HUF_decompress4X4_usingDTable( void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable) { DTableDesc dtd = HUF_getDTableDesc(DTable); if (dtd.tableType != 1) return ERROR(GENERIC); return HUF_decompress4X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); } static size_t HUF_decompress4X4_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2) { const BYTE* ip = (const BYTE*) cSrc; size_t hSize = HUF_readDTableX4_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize); if (HUF_isError(hSize)) return hSize; if (hSize >= cSrcSize) return ERROR(srcSize_wrong); ip += hSize; cSrcSize -= hSize; return HUF_decompress4X4_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2); } size_t HUF_decompress4X4_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize) { return HUF_decompress4X4_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, /* bmi2 */ 0); } size_t HUF_decompress4X4_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; return HUF_decompress4X4_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, sizeof(workSpace)); } size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_TABLELOG_MAX); return HUF_decompress4X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize); } /* ********************************/ /* Generic decompression selector */ /* ********************************/ size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable) { DTableDesc const dtd = HUF_getDTableDesc(DTable); return dtd.tableType ? HUF_decompress1X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) : HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); } size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable) { DTableDesc const dtd = HUF_getDTableDesc(DTable); return dtd.tableType ? HUF_decompress4X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) : HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); } typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t; static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] = { /* single, double, quad */ {{0,0}, {1,1}, {2,2}}, /* Q==0 : impossible */ {{0,0}, {1,1}, {2,2}}, /* Q==1 : impossible */ {{ 38,130}, {1313, 74}, {2151, 38}}, /* Q == 2 : 12-18% */ {{ 448,128}, {1353, 74}, {2238, 41}}, /* Q == 3 : 18-25% */ {{ 556,128}, {1353, 74}, {2238, 47}}, /* Q == 4 : 25-32% */ {{ 714,128}, {1418, 74}, {2436, 53}}, /* Q == 5 : 32-38% */ {{ 883,128}, {1437, 74}, {2464, 61}}, /* Q == 6 : 38-44% */ {{ 897,128}, {1515, 75}, {2622, 68}}, /* Q == 7 : 44-50% */ {{ 926,128}, {1613, 75}, {2730, 75}}, /* Q == 8 : 50-56% */ {{ 947,128}, {1729, 77}, {3359, 77}}, /* Q == 9 : 56-62% */ {{1107,128}, {2083, 81}, {4006, 84}}, /* Q ==10 : 62-69% */ {{1177,128}, {2379, 87}, {4785, 88}}, /* Q ==11 : 69-75% */ {{1242,128}, {2415, 93}, {5155, 84}}, /* Q ==12 : 75-81% */ {{1349,128}, {2644,106}, {5260,106}}, /* Q ==13 : 81-87% */ {{1455,128}, {2422,124}, {4174,124}}, /* Q ==14 : 87-93% */ {{ 722,128}, {1891,145}, {1936,146}}, /* Q ==15 : 93-99% */ }; /** HUF_selectDecoder() : * Tells which decoder is likely to decode faster, * based on a set of pre-computed metrics. * @return : 0==HUF_decompress4X2, 1==HUF_decompress4X4 . * Assumption : 0 < dstSize <= 128 KB */ U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize) { assert(dstSize > 0); assert(dstSize <= 128 KB); /* decoder timing evaluation */ { U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize); /* Q < 16 */ U32 const D256 = (U32)(dstSize >> 8); U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256); U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256); DTime1 += DTime1 >> 3; /* advantage to algorithm using less memory, to reduce cache eviction */ return DTime1 < DTime0; } } typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { static const decompressionAlgo decompress[2] = { HUF_decompress4X2, HUF_decompress4X4 }; /* validation checks */ if (dstSize == 0) return ERROR(dstSize_tooSmall); if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */ if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */ if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */ { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); return decompress[algoNb](dst, dstSize, cSrc, cSrcSize); } } size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { /* validation checks */ if (dstSize == 0) return ERROR(dstSize_tooSmall); if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */ if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */ if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */ { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); return algoNb ? HUF_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) : HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ; } } size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; return HUF_decompress4X_hufOnly_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, sizeof(workSpace)); } size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize) { /* validation checks */ if (dstSize == 0) return ERROR(dstSize_tooSmall); if (cSrcSize == 0) return ERROR(corruption_detected); { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); return algoNb ? HUF_decompress4X4_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize): HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize); } } size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize) { /* validation checks */ if (dstSize == 0) return ERROR(dstSize_tooSmall); if (cSrcSize > dstSize) return ERROR(corruption_detected); /* invalid */ if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */ if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */ { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); return algoNb ? HUF_decompress1X4_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize): HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize); } } size_t HUF_decompress1X_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { U32 workSpace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; return HUF_decompress1X_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, sizeof(workSpace)); } size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2) { DTableDesc const dtd = HUF_getDTableDesc(DTable); return dtd.tableType ? HUF_decompress1X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) : HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2); } size_t HUF_decompress1X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2) { const BYTE* ip = (const BYTE*) cSrc; size_t const hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize); if (HUF_isError(hSize)) return hSize; if (hSize >= cSrcSize) return ERROR(srcSize_wrong); ip += hSize; cSrcSize -= hSize; return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2); } size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2) { DTableDesc const dtd = HUF_getDTableDesc(DTable); return dtd.tableType ? HUF_decompress4X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) : HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2); } size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2) { /* validation checks */ if (dstSize == 0) return ERROR(dstSize_tooSmall); if (cSrcSize == 0) return ERROR(corruption_detected); { U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); return algoNb ? HUF_decompress4X4_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2) : HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2); } } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/mem.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef MEM_H_MODULE #define MEM_H_MODULE #if defined (__cplusplus) extern "C" { #endif /*-**************************************** * Dependencies ******************************************/ #include /* size_t, ptrdiff_t */ #include /* memcpy */ /*-**************************************** * Compiler specifics ******************************************/ #if defined(_MSC_VER) /* Visual Studio */ # include /* _byteswap_ulong */ # include /* _byteswap_* */ #endif #if defined(__GNUC__) # define MEM_STATIC static __inline __attribute__((unused)) #elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) # define MEM_STATIC static inline #elif defined(_MSC_VER) # define MEM_STATIC static __inline #else # define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */ #endif /* code only tested on 32 and 64 bits systems */ #define MEM_STATIC_ASSERT(c) { enum { MEM_static_assert = 1/(int)(!!(c)) }; } MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); } /*-************************************************************** * Basic Types *****************************************************************/ #if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) # include typedef uint8_t BYTE; typedef uint16_t U16; typedef int16_t S16; typedef uint32_t U32; typedef int32_t S32; typedef uint64_t U64; typedef int64_t S64; #else typedef unsigned char BYTE; typedef unsigned short U16; typedef signed short S16; typedef unsigned int U32; typedef signed int S32; typedef unsigned long long U64; typedef signed long long S64; #endif /*-************************************************************** * Memory I/O *****************************************************************/ /* MEM_FORCE_MEMORY_ACCESS : * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable. * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal. * The below switch allow to select different access method for improved performance. * Method 0 (default) : use `memcpy()`. Safe and portable. * Method 1 : `__packed` statement. It depends on compiler extension (i.e., not portable). * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`. * Method 2 : direct access. This method is portable but violate C standard. * It can generate buggy code on targets depending on alignment. * In some circumstances, it's the only known way to get the most performance (i.e. GCC + ARMv6) * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details. * Prefer these methods in priority order (0 > 1 > 2) */ #ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */ # if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) ) # define MEM_FORCE_MEMORY_ACCESS 2 # elif defined(__INTEL_COMPILER) || defined(__GNUC__) # define MEM_FORCE_MEMORY_ACCESS 1 # endif #endif MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; } MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; } MEM_STATIC unsigned MEM_isLittleEndian(void) { const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */ return one.c[0]; } #if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2) /* violates C standard, by lying on structure alignment. Only use if no other choice to achieve best performance on target platform */ MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; } MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; } MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; } MEM_STATIC size_t MEM_readST(const void* memPtr) { return *(const size_t*) memPtr; } MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; } MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; } MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; } #elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1) /* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */ /* currently only defined for gcc and icc */ #if defined(_MSC_VER) || (defined(__INTEL_COMPILER) && defined(WIN32)) __pragma( pack(push, 1) ) typedef struct { U16 v; } unalign16; typedef struct { U32 v; } unalign32; typedef struct { U64 v; } unalign64; typedef struct { size_t v; } unalignArch; __pragma( pack(pop) ) #else typedef struct { U16 v; } __attribute__((packed)) unalign16; typedef struct { U32 v; } __attribute__((packed)) unalign32; typedef struct { U64 v; } __attribute__((packed)) unalign64; typedef struct { size_t v; } __attribute__((packed)) unalignArch; #endif MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign16*)ptr)->v; } MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign32*)ptr)->v; } MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign64*)ptr)->v; } MEM_STATIC size_t MEM_readST(const void* ptr) { return ((const unalignArch*)ptr)->v; } MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign16*)memPtr)->v = value; } MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign32*)memPtr)->v = value; } MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign64*)memPtr)->v = value; } #else /* default method, safe and standard. can sometimes prove slower */ MEM_STATIC U16 MEM_read16(const void* memPtr) { U16 val; memcpy(&val, memPtr, sizeof(val)); return val; } MEM_STATIC U32 MEM_read32(const void* memPtr) { U32 val; memcpy(&val, memPtr, sizeof(val)); return val; } MEM_STATIC U64 MEM_read64(const void* memPtr) { U64 val; memcpy(&val, memPtr, sizeof(val)); return val; } MEM_STATIC size_t MEM_readST(const void* memPtr) { size_t val; memcpy(&val, memPtr, sizeof(val)); return val; } MEM_STATIC void MEM_write16(void* memPtr, U16 value) { memcpy(memPtr, &value, sizeof(value)); } MEM_STATIC void MEM_write32(void* memPtr, U32 value) { memcpy(memPtr, &value, sizeof(value)); } MEM_STATIC void MEM_write64(void* memPtr, U64 value) { memcpy(memPtr, &value, sizeof(value)); } #endif /* MEM_FORCE_MEMORY_ACCESS */ MEM_STATIC U32 MEM_swap32(U32 in) { #if defined(_MSC_VER) /* Visual Studio */ return _byteswap_ulong(in); #elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403) return __builtin_bswap32(in); #else return ((in << 24) & 0xff000000 ) | ((in << 8) & 0x00ff0000 ) | ((in >> 8) & 0x0000ff00 ) | ((in >> 24) & 0x000000ff ); #endif } MEM_STATIC U64 MEM_swap64(U64 in) { #if defined(_MSC_VER) /* Visual Studio */ return _byteswap_uint64(in); #elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403) return __builtin_bswap64(in); #else return ((in << 56) & 0xff00000000000000ULL) | ((in << 40) & 0x00ff000000000000ULL) | ((in << 24) & 0x0000ff0000000000ULL) | ((in << 8) & 0x000000ff00000000ULL) | ((in >> 8) & 0x00000000ff000000ULL) | ((in >> 24) & 0x0000000000ff0000ULL) | ((in >> 40) & 0x000000000000ff00ULL) | ((in >> 56) & 0x00000000000000ffULL); #endif } MEM_STATIC size_t MEM_swapST(size_t in) { if (MEM_32bits()) return (size_t)MEM_swap32((U32)in); else return (size_t)MEM_swap64((U64)in); } /*=== Little endian r/w ===*/ MEM_STATIC U16 MEM_readLE16(const void* memPtr) { if (MEM_isLittleEndian()) return MEM_read16(memPtr); else { const BYTE* p = (const BYTE*)memPtr; return (U16)(p[0] + (p[1]<<8)); } } MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val) { if (MEM_isLittleEndian()) { MEM_write16(memPtr, val); } else { BYTE* p = (BYTE*)memPtr; p[0] = (BYTE)val; p[1] = (BYTE)(val>>8); } } MEM_STATIC U32 MEM_readLE24(const void* memPtr) { return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16); } MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val) { MEM_writeLE16(memPtr, (U16)val); ((BYTE*)memPtr)[2] = (BYTE)(val>>16); } MEM_STATIC U32 MEM_readLE32(const void* memPtr) { if (MEM_isLittleEndian()) return MEM_read32(memPtr); else return MEM_swap32(MEM_read32(memPtr)); } MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32) { if (MEM_isLittleEndian()) MEM_write32(memPtr, val32); else MEM_write32(memPtr, MEM_swap32(val32)); } MEM_STATIC U64 MEM_readLE64(const void* memPtr) { if (MEM_isLittleEndian()) return MEM_read64(memPtr); else return MEM_swap64(MEM_read64(memPtr)); } MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64) { if (MEM_isLittleEndian()) MEM_write64(memPtr, val64); else MEM_write64(memPtr, MEM_swap64(val64)); } MEM_STATIC size_t MEM_readLEST(const void* memPtr) { if (MEM_32bits()) return (size_t)MEM_readLE32(memPtr); else return (size_t)MEM_readLE64(memPtr); } MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val) { if (MEM_32bits()) MEM_writeLE32(memPtr, (U32)val); else MEM_writeLE64(memPtr, (U64)val); } /*=== Big endian r/w ===*/ MEM_STATIC U32 MEM_readBE32(const void* memPtr) { if (MEM_isLittleEndian()) return MEM_swap32(MEM_read32(memPtr)); else return MEM_read32(memPtr); } MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32) { if (MEM_isLittleEndian()) MEM_write32(memPtr, MEM_swap32(val32)); else MEM_write32(memPtr, val32); } MEM_STATIC U64 MEM_readBE64(const void* memPtr) { if (MEM_isLittleEndian()) return MEM_swap64(MEM_read64(memPtr)); else return MEM_read64(memPtr); } MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64) { if (MEM_isLittleEndian()) MEM_write64(memPtr, MEM_swap64(val64)); else MEM_write64(memPtr, val64); } MEM_STATIC size_t MEM_readBEST(const void* memPtr) { if (MEM_32bits()) return (size_t)MEM_readBE32(memPtr); else return (size_t)MEM_readBE64(memPtr); } MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val) { if (MEM_32bits()) MEM_writeBE32(memPtr, (U32)val); else MEM_writeBE64(memPtr, (U64)val); } #if defined (__cplusplus) } #endif #endif /* MEM_H_MODULE */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/pool.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /* ====== Dependencies ======= */ #include /* size_t */ #include "pool.h" #include "zstd_internal.h" /* ZSTD_malloc, ZSTD_free */ /* ====== Compiler specifics ====== */ #if defined(_MSC_VER) # pragma warning(disable : 4204) /* disable: C4204: non-constant aggregate initializer */ #endif #ifdef ZSTD_MULTITHREAD #include "threading.h" /* pthread adaptation */ /* A job is a function and an opaque argument */ typedef struct POOL_job_s { POOL_function function; void *opaque; } POOL_job; struct POOL_ctx_s { ZSTD_customMem customMem; /* Keep track of the threads */ ZSTD_pthread_t *threads; size_t numThreads; /* The queue is a circular buffer */ POOL_job *queue; size_t queueHead; size_t queueTail; size_t queueSize; /* The number of threads working on jobs */ size_t numThreadsBusy; /* Indicates if the queue is empty */ int queueEmpty; /* The mutex protects the queue */ ZSTD_pthread_mutex_t queueMutex; /* Condition variable for pushers to wait on when the queue is full */ ZSTD_pthread_cond_t queuePushCond; /* Condition variables for poppers to wait on when the queue is empty */ ZSTD_pthread_cond_t queuePopCond; /* Indicates if the queue is shutting down */ int shutdown; }; /* POOL_thread() : Work thread for the thread pool. Waits for jobs and executes them. @returns : NULL on failure else non-null. */ static void* POOL_thread(void* opaque) { POOL_ctx* const ctx = (POOL_ctx*)opaque; if (!ctx) { return NULL; } for (;;) { /* Lock the mutex and wait for a non-empty queue or until shutdown */ ZSTD_pthread_mutex_lock(&ctx->queueMutex); while (ctx->queueEmpty && !ctx->shutdown) { ZSTD_pthread_cond_wait(&ctx->queuePopCond, &ctx->queueMutex); } /* empty => shutting down: so stop */ if (ctx->queueEmpty) { ZSTD_pthread_mutex_unlock(&ctx->queueMutex); return opaque; } /* Pop a job off the queue */ { POOL_job const job = ctx->queue[ctx->queueHead]; ctx->queueHead = (ctx->queueHead + 1) % ctx->queueSize; ctx->numThreadsBusy++; ctx->queueEmpty = ctx->queueHead == ctx->queueTail; /* Unlock the mutex, signal a pusher, and run the job */ ZSTD_pthread_mutex_unlock(&ctx->queueMutex); ZSTD_pthread_cond_signal(&ctx->queuePushCond); job.function(job.opaque); /* If the intended queue size was 0, signal after finishing job */ if (ctx->queueSize == 1) { ZSTD_pthread_mutex_lock(&ctx->queueMutex); ctx->numThreadsBusy--; ZSTD_pthread_mutex_unlock(&ctx->queueMutex); ZSTD_pthread_cond_signal(&ctx->queuePushCond); } } } /* for (;;) */ /* Unreachable */ } POOL_ctx* POOL_create(size_t numThreads, size_t queueSize) { return POOL_create_advanced(numThreads, queueSize, ZSTD_defaultCMem); } POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize, ZSTD_customMem customMem) { POOL_ctx* ctx; /* Check the parameters */ if (!numThreads) { return NULL; } /* Allocate the context and zero initialize */ ctx = (POOL_ctx*)ZSTD_calloc(sizeof(POOL_ctx), customMem); if (!ctx) { return NULL; } /* Initialize the job queue. * It needs one extra space since one space is wasted to differentiate empty * and full queues. */ ctx->queueSize = queueSize + 1; ctx->queue = (POOL_job*)ZSTD_malloc(ctx->queueSize * sizeof(POOL_job), customMem); ctx->queueHead = 0; ctx->queueTail = 0; ctx->numThreadsBusy = 0; ctx->queueEmpty = 1; (void)ZSTD_pthread_mutex_init(&ctx->queueMutex, NULL); (void)ZSTD_pthread_cond_init(&ctx->queuePushCond, NULL); (void)ZSTD_pthread_cond_init(&ctx->queuePopCond, NULL); ctx->shutdown = 0; /* Allocate space for the thread handles */ ctx->threads = (ZSTD_pthread_t*)ZSTD_malloc(numThreads * sizeof(ZSTD_pthread_t), customMem); ctx->numThreads = 0; ctx->customMem = customMem; /* Check for errors */ if (!ctx->threads || !ctx->queue) { POOL_free(ctx); return NULL; } /* Initialize the threads */ { size_t i; for (i = 0; i < numThreads; ++i) { if (ZSTD_pthread_create(&ctx->threads[i], NULL, &POOL_thread, ctx)) { ctx->numThreads = i; POOL_free(ctx); return NULL; } } ctx->numThreads = numThreads; } return ctx; } /*! POOL_join() : Shutdown the queue, wake any sleeping threads, and join all of the threads. */ static void POOL_join(POOL_ctx* ctx) { /* Shut down the queue */ ZSTD_pthread_mutex_lock(&ctx->queueMutex); ctx->shutdown = 1; ZSTD_pthread_mutex_unlock(&ctx->queueMutex); /* Wake up sleeping threads */ ZSTD_pthread_cond_broadcast(&ctx->queuePushCond); ZSTD_pthread_cond_broadcast(&ctx->queuePopCond); /* Join all of the threads */ { size_t i; for (i = 0; i < ctx->numThreads; ++i) { ZSTD_pthread_join(ctx->threads[i], NULL); } } } void POOL_free(POOL_ctx *ctx) { if (!ctx) { return; } POOL_join(ctx); ZSTD_pthread_mutex_destroy(&ctx->queueMutex); ZSTD_pthread_cond_destroy(&ctx->queuePushCond); ZSTD_pthread_cond_destroy(&ctx->queuePopCond); ZSTD_free(ctx->queue, ctx->customMem); ZSTD_free(ctx->threads, ctx->customMem); ZSTD_free(ctx, ctx->customMem); } size_t POOL_sizeof(POOL_ctx *ctx) { if (ctx==NULL) return 0; /* supports sizeof NULL */ return sizeof(*ctx) + ctx->queueSize * sizeof(POOL_job) + ctx->numThreads * sizeof(ZSTD_pthread_t); } /** * Returns 1 if the queue is full and 0 otherwise. * * If the queueSize is 1 (the pool was created with an intended queueSize of 0), * then a queue is empty if there is a thread free and no job is waiting. */ static int isQueueFull(POOL_ctx const* ctx) { if (ctx->queueSize > 1) { return ctx->queueHead == ((ctx->queueTail + 1) % ctx->queueSize); } else { return ctx->numThreadsBusy == ctx->numThreads || !ctx->queueEmpty; } } static void POOL_add_internal(POOL_ctx* ctx, POOL_function function, void *opaque) { POOL_job const job = {function, opaque}; assert(ctx != NULL); if (ctx->shutdown) return; ctx->queueEmpty = 0; ctx->queue[ctx->queueTail] = job; ctx->queueTail = (ctx->queueTail + 1) % ctx->queueSize; ZSTD_pthread_cond_signal(&ctx->queuePopCond); } void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque) { assert(ctx != NULL); ZSTD_pthread_mutex_lock(&ctx->queueMutex); /* Wait until there is space in the queue for the new job */ while (isQueueFull(ctx) && (!ctx->shutdown)) { ZSTD_pthread_cond_wait(&ctx->queuePushCond, &ctx->queueMutex); } POOL_add_internal(ctx, function, opaque); ZSTD_pthread_mutex_unlock(&ctx->queueMutex); } int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque) { assert(ctx != NULL); ZSTD_pthread_mutex_lock(&ctx->queueMutex); if (isQueueFull(ctx)) { ZSTD_pthread_mutex_unlock(&ctx->queueMutex); return 0; } POOL_add_internal(ctx, function, opaque); ZSTD_pthread_mutex_unlock(&ctx->queueMutex); return 1; } #else /* ZSTD_MULTITHREAD not defined */ /* ========================== */ /* No multi-threading support */ /* ========================== */ /* We don't need any data, but if it is empty, malloc() might return NULL. */ struct POOL_ctx_s { int dummy; }; static POOL_ctx g_ctx; POOL_ctx* POOL_create(size_t numThreads, size_t queueSize) { return POOL_create_advanced(numThreads, queueSize, ZSTD_defaultCMem); } POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize, ZSTD_customMem customMem) { (void)numThreads; (void)queueSize; (void)customMem; return &g_ctx; } void POOL_free(POOL_ctx* ctx) { assert(!ctx || ctx == &g_ctx); (void)ctx; } void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque) { (void)ctx; function(opaque); } int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque) { (void)ctx; function(opaque); return 1; } size_t POOL_sizeof(POOL_ctx* ctx) { if (ctx==NULL) return 0; /* supports sizeof NULL */ assert(ctx == &g_ctx); return sizeof(*ctx); } #endif /* ZSTD_MULTITHREAD */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/pool.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef POOL_H #define POOL_H #if defined (__cplusplus) extern "C" { #endif #include /* size_t */ #define ZSTD_STATIC_LINKING_ONLY /* ZSTD_customMem */ #include "zstd.h" typedef struct POOL_ctx_s POOL_ctx; /*! POOL_create() : * Create a thread pool with at most `numThreads` threads. * `numThreads` must be at least 1. * The maximum number of queued jobs before blocking is `queueSize`. * @return : POOL_ctx pointer on success, else NULL. */ POOL_ctx* POOL_create(size_t numThreads, size_t queueSize); POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize, ZSTD_customMem customMem); /*! POOL_free() : Free a thread pool returned by POOL_create(). */ void POOL_free(POOL_ctx* ctx); /*! POOL_sizeof() : return memory usage of pool returned by POOL_create(). */ size_t POOL_sizeof(POOL_ctx* ctx); /*! POOL_function : The function type that can be added to a thread pool. */ typedef void (*POOL_function)(void*); /*! POOL_add_function : The function type for a generic thread pool add function. */ typedef void (*POOL_add_function)(void*, POOL_function, void*); /*! POOL_add() : Add the job `function(opaque)` to the thread pool. `ctx` must be valid. Possibly blocks until there is room in the queue. Note : The function may be executed asynchronously, so `opaque` must live until the function has been completed. */ void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque); /*! POOL_tryAdd() : Add the job `function(opaque)` to the thread pool if a worker is available. return immediately otherwise. @return : 1 if successful, 0 if not. */ int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque); #if defined (__cplusplus) } #endif #endif ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/threading.c ================================================ /** * Copyright (c) 2016 Tino Reichardt * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * * You can contact the author at: * - zstdmt source repository: https://github.com/mcmilk/zstdmt */ /** * This file will hold wrapper for systems, which do not support pthreads */ /* create fake symbol to avoid empty trnaslation unit warning */ int g_ZSTD_threading_useles_symbol; #if defined(ZSTD_MULTITHREAD) && defined(_WIN32) /** * Windows minimalist Pthread Wrapper, based on : * http://www.cse.wustl.edu/~schmidt/win32-cv-1.html */ /* === Dependencies === */ #include #include #include "threading.h" /* === Implementation === */ static unsigned __stdcall worker(void *arg) { ZSTD_pthread_t* const thread = (ZSTD_pthread_t*) arg; thread->arg = thread->start_routine(thread->arg); return 0; } int ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused, void* (*start_routine) (void*), void* arg) { (void)unused; thread->arg = arg; thread->start_routine = start_routine; thread->handle = (HANDLE) _beginthreadex(NULL, 0, worker, thread, 0, NULL); if (!thread->handle) return errno; else return 0; } int ZSTD_pthread_join(ZSTD_pthread_t thread, void **value_ptr) { DWORD result; if (!thread.handle) return 0; result = WaitForSingleObject(thread.handle, INFINITE); switch (result) { case WAIT_OBJECT_0: if (value_ptr) *value_ptr = thread.arg; return 0; case WAIT_ABANDONED: return EINVAL; default: return GetLastError(); } } #endif /* ZSTD_MULTITHREAD */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/threading.h ================================================ /** * Copyright (c) 2016 Tino Reichardt * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * * You can contact the author at: * - zstdmt source repository: https://github.com/mcmilk/zstdmt */ #ifndef THREADING_H_938743 #define THREADING_H_938743 #if defined (__cplusplus) extern "C" { #endif #if defined(ZSTD_MULTITHREAD) && defined(_WIN32) /** * Windows minimalist Pthread Wrapper, based on : * http://www.cse.wustl.edu/~schmidt/win32-cv-1.html */ #ifdef WINVER # undef WINVER #endif #define WINVER 0x0600 #ifdef _WIN32_WINNT # undef _WIN32_WINNT #endif #define _WIN32_WINNT 0x0600 #ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN #endif #undef ERROR /* reported already defined on VS 2015 (Rich Geldreich) */ #include #undef ERROR #define ERROR(name) ZSTD_ERROR(name) /* mutex */ #define ZSTD_pthread_mutex_t CRITICAL_SECTION #define ZSTD_pthread_mutex_init(a, b) ((void)(b), InitializeCriticalSection((a)), 0) #define ZSTD_pthread_mutex_destroy(a) DeleteCriticalSection((a)) #define ZSTD_pthread_mutex_lock(a) EnterCriticalSection((a)) #define ZSTD_pthread_mutex_unlock(a) LeaveCriticalSection((a)) /* condition variable */ #define ZSTD_pthread_cond_t CONDITION_VARIABLE #define ZSTD_pthread_cond_init(a, b) ((void)(b), InitializeConditionVariable((a)), 0) #define ZSTD_pthread_cond_destroy(a) ((void)(a)) #define ZSTD_pthread_cond_wait(a, b) SleepConditionVariableCS((a), (b), INFINITE) #define ZSTD_pthread_cond_signal(a) WakeConditionVariable((a)) #define ZSTD_pthread_cond_broadcast(a) WakeAllConditionVariable((a)) /* ZSTD_pthread_create() and ZSTD_pthread_join() */ typedef struct { HANDLE handle; void* (*start_routine)(void*); void* arg; } ZSTD_pthread_t; int ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused, void* (*start_routine) (void*), void* arg); int ZSTD_pthread_join(ZSTD_pthread_t thread, void** value_ptr); /** * add here more wrappers as required */ #elif defined(ZSTD_MULTITHREAD) /* posix assumed ; need a better detection method */ /* === POSIX Systems === */ # include #define ZSTD_pthread_mutex_t pthread_mutex_t #define ZSTD_pthread_mutex_init(a, b) pthread_mutex_init((a), (b)) #define ZSTD_pthread_mutex_destroy(a) pthread_mutex_destroy((a)) #define ZSTD_pthread_mutex_lock(a) pthread_mutex_lock((a)) #define ZSTD_pthread_mutex_unlock(a) pthread_mutex_unlock((a)) #define ZSTD_pthread_cond_t pthread_cond_t #define ZSTD_pthread_cond_init(a, b) pthread_cond_init((a), (b)) #define ZSTD_pthread_cond_destroy(a) pthread_cond_destroy((a)) #define ZSTD_pthread_cond_wait(a, b) pthread_cond_wait((a), (b)) #define ZSTD_pthread_cond_signal(a) pthread_cond_signal((a)) #define ZSTD_pthread_cond_broadcast(a) pthread_cond_broadcast((a)) #define ZSTD_pthread_t pthread_t #define ZSTD_pthread_create(a, b, c, d) pthread_create((a), (b), (c), (d)) #define ZSTD_pthread_join(a, b) pthread_join((a),(b)) #else /* ZSTD_MULTITHREAD not defined */ /* No multithreading support */ typedef int ZSTD_pthread_mutex_t; #define ZSTD_pthread_mutex_init(a, b) ((void)(a), (void)(b), 0) #define ZSTD_pthread_mutex_destroy(a) ((void)(a)) #define ZSTD_pthread_mutex_lock(a) ((void)(a)) #define ZSTD_pthread_mutex_unlock(a) ((void)(a)) typedef int ZSTD_pthread_cond_t; #define ZSTD_pthread_cond_init(a, b) ((void)(a), (void)(b), 0) #define ZSTD_pthread_cond_destroy(a) ((void)(a)) #define ZSTD_pthread_cond_wait(a, b) ((void)(a), (void)(b)) #define ZSTD_pthread_cond_signal(a) ((void)(a)) #define ZSTD_pthread_cond_broadcast(a) ((void)(a)) /* do not use ZSTD_pthread_t */ #endif /* ZSTD_MULTITHREAD */ #if defined (__cplusplus) } #endif #endif /* THREADING_H_938743 */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/xxhash.c ================================================ /* * xxHash - Fast Hash algorithm * Copyright (C) 2012-2016, Yann Collet * * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following disclaimer * in the documentation and/or other materials provided with the * distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * You can contact the author at : * - xxHash homepage: http://www.xxhash.com * - xxHash source repository : https://github.com/Cyan4973/xxHash */ /* ************************************* * Tuning parameters ***************************************/ /*!XXH_FORCE_MEMORY_ACCESS : * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable. * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal. * The below switch allow to select different access method for improved performance. * Method 0 (default) : use `memcpy()`. Safe and portable. * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable). * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`. * Method 2 : direct access. This method doesn't depend on compiler but violate C standard. * It can generate buggy code on targets which do not support unaligned memory accesses. * But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) * See http://stackoverflow.com/a/32095106/646947 for details. * Prefer these methods in priority order (0 > 1 > 2) */ #ifndef XXH_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */ # if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) ) # define XXH_FORCE_MEMORY_ACCESS 2 # elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \ (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) )) # define XXH_FORCE_MEMORY_ACCESS 1 # endif #endif /*!XXH_ACCEPT_NULL_INPUT_POINTER : * If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer. * When this option is enabled, xxHash output for null input pointers will be the same as a null-length input. * By default, this option is disabled. To enable it, uncomment below define : */ /* #define XXH_ACCEPT_NULL_INPUT_POINTER 1 */ /*!XXH_FORCE_NATIVE_FORMAT : * By default, xxHash library provides endian-independant Hash values, based on little-endian convention. * Results are therefore identical for little-endian and big-endian CPU. * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format. * Should endian-independance be of no importance for your application, you may set the #define below to 1, * to improve speed for Big-endian CPU. * This option has no impact on Little_Endian CPU. */ #ifndef XXH_FORCE_NATIVE_FORMAT /* can be defined externally */ # define XXH_FORCE_NATIVE_FORMAT 0 #endif /*!XXH_FORCE_ALIGN_CHECK : * This is a minor performance trick, only useful with lots of very small keys. * It means : check for aligned/unaligned input. * The check costs one initial branch per hash; set to 0 when the input data * is guaranteed to be aligned. */ #ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */ # if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64) # define XXH_FORCE_ALIGN_CHECK 0 # else # define XXH_FORCE_ALIGN_CHECK 1 # endif #endif /* ************************************* * Includes & Memory related functions ***************************************/ /* Modify the local functions below should you wish to use some other memory routines */ /* for malloc(), free() */ #include static void* XXH_malloc(size_t s) { return malloc(s); } static void XXH_free (void* p) { free(p); } /* for memcpy() */ #include static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); } #ifndef XXH_STATIC_LINKING_ONLY # define XXH_STATIC_LINKING_ONLY #endif #include "xxhash.h" /* ************************************* * Compiler Specific Options ***************************************/ #if defined (__GNUC__) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ # define INLINE_KEYWORD inline #else # define INLINE_KEYWORD #endif #if defined(__GNUC__) # define FORCE_INLINE_ATTR __attribute__((always_inline)) #elif defined(_MSC_VER) # define FORCE_INLINE_ATTR __forceinline #else # define FORCE_INLINE_ATTR #endif #define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR #ifdef _MSC_VER # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ #endif /* ************************************* * Basic Types ***************************************/ #ifndef MEM_MODULE # define MEM_MODULE # if !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) # include typedef uint8_t BYTE; typedef uint16_t U16; typedef uint32_t U32; typedef int32_t S32; typedef uint64_t U64; # else typedef unsigned char BYTE; typedef unsigned short U16; typedef unsigned int U32; typedef signed int S32; typedef unsigned long long U64; /* if your compiler doesn't support unsigned long long, replace by another 64-bit type here. Note that xxhash.h will also need to be updated. */ # endif #endif #if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2)) /* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */ static U32 XXH_read32(const void* memPtr) { return *(const U32*) memPtr; } static U64 XXH_read64(const void* memPtr) { return *(const U64*) memPtr; } #elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1)) /* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */ /* currently only defined for gcc and icc */ typedef union { U32 u32; U64 u64; } __attribute__((packed)) unalign; static U32 XXH_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } static U64 XXH_read64(const void* ptr) { return ((const unalign*)ptr)->u64; } #else /* portable and safe solution. Generally efficient. * see : http://stackoverflow.com/a/32095106/646947 */ static U32 XXH_read32(const void* memPtr) { U32 val; memcpy(&val, memPtr, sizeof(val)); return val; } static U64 XXH_read64(const void* memPtr) { U64 val; memcpy(&val, memPtr, sizeof(val)); return val; } #endif /* XXH_FORCE_DIRECT_MEMORY_ACCESS */ /* **************************************** * Compiler-specific Functions and Macros ******************************************/ #define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) /* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */ #if defined(_MSC_VER) # define XXH_rotl32(x,r) _rotl(x,r) # define XXH_rotl64(x,r) _rotl64(x,r) #else # define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r))) # define XXH_rotl64(x,r) ((x << r) | (x >> (64 - r))) #endif #if defined(_MSC_VER) /* Visual Studio */ # define XXH_swap32 _byteswap_ulong # define XXH_swap64 _byteswap_uint64 #elif GCC_VERSION >= 403 # define XXH_swap32 __builtin_bswap32 # define XXH_swap64 __builtin_bswap64 #else static U32 XXH_swap32 (U32 x) { return ((x << 24) & 0xff000000 ) | ((x << 8) & 0x00ff0000 ) | ((x >> 8) & 0x0000ff00 ) | ((x >> 24) & 0x000000ff ); } static U64 XXH_swap64 (U64 x) { return ((x << 56) & 0xff00000000000000ULL) | ((x << 40) & 0x00ff000000000000ULL) | ((x << 24) & 0x0000ff0000000000ULL) | ((x << 8) & 0x000000ff00000000ULL) | ((x >> 8) & 0x00000000ff000000ULL) | ((x >> 24) & 0x0000000000ff0000ULL) | ((x >> 40) & 0x000000000000ff00ULL) | ((x >> 56) & 0x00000000000000ffULL); } #endif /* ************************************* * Architecture Macros ***************************************/ typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess; /* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */ #ifndef XXH_CPU_LITTLE_ENDIAN static const int g_one = 1; # define XXH_CPU_LITTLE_ENDIAN (*(const char*)(&g_one)) #endif /* *************************** * Memory reads *****************************/ typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment; FORCE_INLINE_TEMPLATE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align) { if (align==XXH_unaligned) return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr)); else return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr); } FORCE_INLINE_TEMPLATE U32 XXH_readLE32(const void* ptr, XXH_endianess endian) { return XXH_readLE32_align(ptr, endian, XXH_unaligned); } static U32 XXH_readBE32(const void* ptr) { return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr); } FORCE_INLINE_TEMPLATE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align) { if (align==XXH_unaligned) return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr)); else return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr); } FORCE_INLINE_TEMPLATE U64 XXH_readLE64(const void* ptr, XXH_endianess endian) { return XXH_readLE64_align(ptr, endian, XXH_unaligned); } static U64 XXH_readBE64(const void* ptr) { return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr); } /* ************************************* * Macros ***************************************/ #define XXH_STATIC_ASSERT(c) { enum { XXH_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ /* ************************************* * Constants ***************************************/ static const U32 PRIME32_1 = 2654435761U; static const U32 PRIME32_2 = 2246822519U; static const U32 PRIME32_3 = 3266489917U; static const U32 PRIME32_4 = 668265263U; static const U32 PRIME32_5 = 374761393U; static const U64 PRIME64_1 = 11400714785074694791ULL; static const U64 PRIME64_2 = 14029467366897019727ULL; static const U64 PRIME64_3 = 1609587929392839161ULL; static const U64 PRIME64_4 = 9650029242287828579ULL; static const U64 PRIME64_5 = 2870177450012600261ULL; XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; } /* ************************** * Utils ****************************/ XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* restrict dstState, const XXH32_state_t* restrict srcState) { memcpy(dstState, srcState, sizeof(*dstState)); } XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* restrict dstState, const XXH64_state_t* restrict srcState) { memcpy(dstState, srcState, sizeof(*dstState)); } /* *************************** * Simple Hash Functions *****************************/ static U32 XXH32_round(U32 seed, U32 input) { seed += input * PRIME32_2; seed = XXH_rotl32(seed, 13); seed *= PRIME32_1; return seed; } FORCE_INLINE_TEMPLATE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align) { const BYTE* p = (const BYTE*)input; const BYTE* bEnd = p + len; U32 h32; #define XXH_get32bits(p) XXH_readLE32_align(p, endian, align) #ifdef XXH_ACCEPT_NULL_INPUT_POINTER if (p==NULL) { len=0; bEnd=p=(const BYTE*)(size_t)16; } #endif if (len>=16) { const BYTE* const limit = bEnd - 16; U32 v1 = seed + PRIME32_1 + PRIME32_2; U32 v2 = seed + PRIME32_2; U32 v3 = seed + 0; U32 v4 = seed - PRIME32_1; do { v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4; v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4; v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4; v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4; } while (p<=limit); h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18); } else { h32 = seed + PRIME32_5; } h32 += (U32) len; while (p+4<=bEnd) { h32 += XXH_get32bits(p) * PRIME32_3; h32 = XXH_rotl32(h32, 17) * PRIME32_4 ; p+=4; } while (p> 15; h32 *= PRIME32_2; h32 ^= h32 >> 13; h32 *= PRIME32_3; h32 ^= h32 >> 16; return h32; } XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed) { #if 0 /* Simple version, good for code maintenance, but unfortunately slow for small inputs */ XXH32_CREATESTATE_STATIC(state); XXH32_reset(state, seed); XXH32_update(state, input, len); return XXH32_digest(state); #else XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; if (XXH_FORCE_ALIGN_CHECK) { if ((((size_t)input) & 3) == 0) { /* Input is 4-bytes aligned, leverage the speed benefit */ if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned); else return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned); } } if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned); else return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned); #endif } static U64 XXH64_round(U64 acc, U64 input) { acc += input * PRIME64_2; acc = XXH_rotl64(acc, 31); acc *= PRIME64_1; return acc; } static U64 XXH64_mergeRound(U64 acc, U64 val) { val = XXH64_round(0, val); acc ^= val; acc = acc * PRIME64_1 + PRIME64_4; return acc; } FORCE_INLINE_TEMPLATE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align) { const BYTE* p = (const BYTE*)input; const BYTE* const bEnd = p + len; U64 h64; #define XXH_get64bits(p) XXH_readLE64_align(p, endian, align) #ifdef XXH_ACCEPT_NULL_INPUT_POINTER if (p==NULL) { len=0; bEnd=p=(const BYTE*)(size_t)32; } #endif if (len>=32) { const BYTE* const limit = bEnd - 32; U64 v1 = seed + PRIME64_1 + PRIME64_2; U64 v2 = seed + PRIME64_2; U64 v3 = seed + 0; U64 v4 = seed - PRIME64_1; do { v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8; v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8; v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8; v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8; } while (p<=limit); h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18); h64 = XXH64_mergeRound(h64, v1); h64 = XXH64_mergeRound(h64, v2); h64 = XXH64_mergeRound(h64, v3); h64 = XXH64_mergeRound(h64, v4); } else { h64 = seed + PRIME64_5; } h64 += (U64) len; while (p+8<=bEnd) { U64 const k1 = XXH64_round(0, XXH_get64bits(p)); h64 ^= k1; h64 = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; p+=8; } if (p+4<=bEnd) { h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1; h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3; p+=4; } while (p> 33; h64 *= PRIME64_2; h64 ^= h64 >> 29; h64 *= PRIME64_3; h64 ^= h64 >> 32; return h64; } XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed) { #if 0 /* Simple version, good for code maintenance, but unfortunately slow for small inputs */ XXH64_CREATESTATE_STATIC(state); XXH64_reset(state, seed); XXH64_update(state, input, len); return XXH64_digest(state); #else XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; if (XXH_FORCE_ALIGN_CHECK) { if ((((size_t)input) & 7)==0) { /* Input is aligned, let's leverage the speed advantage */ if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned); else return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned); } } if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned); else return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned); #endif } /* ************************************************** * Advanced Hash Functions ****************************************************/ XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void) { return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t)); } XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr) { XXH_free(statePtr); return XXH_OK; } XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void) { return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t)); } XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr) { XXH_free(statePtr); return XXH_OK; } /*** Hash feed ***/ XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed) { XXH32_state_t state; /* using a local state to memcpy() in order to avoid strict-aliasing warnings */ memset(&state, 0, sizeof(state)-4); /* do not write into reserved, for future removal */ state.v1 = seed + PRIME32_1 + PRIME32_2; state.v2 = seed + PRIME32_2; state.v3 = seed + 0; state.v4 = seed - PRIME32_1; memcpy(statePtr, &state, sizeof(state)); return XXH_OK; } XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed) { XXH64_state_t state; /* using a local state to memcpy() in order to avoid strict-aliasing warnings */ memset(&state, 0, sizeof(state)-8); /* do not write into reserved, for future removal */ state.v1 = seed + PRIME64_1 + PRIME64_2; state.v2 = seed + PRIME64_2; state.v3 = seed + 0; state.v4 = seed - PRIME64_1; memcpy(statePtr, &state, sizeof(state)); return XXH_OK; } FORCE_INLINE_TEMPLATE XXH_errorcode XXH32_update_endian (XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian) { const BYTE* p = (const BYTE*)input; const BYTE* const bEnd = p + len; #ifdef XXH_ACCEPT_NULL_INPUT_POINTER if (input==NULL) return XXH_ERROR; #endif state->total_len_32 += (unsigned)len; state->large_len |= (len>=16) | (state->total_len_32>=16); if (state->memsize + len < 16) { /* fill in tmp buffer */ XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len); state->memsize += (unsigned)len; return XXH_OK; } if (state->memsize) { /* some data left from previous update */ XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize); { const U32* p32 = state->mem32; state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++; state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++; state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++; state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian)); p32++; } p += 16-state->memsize; state->memsize = 0; } if (p <= bEnd-16) { const BYTE* const limit = bEnd - 16; U32 v1 = state->v1; U32 v2 = state->v2; U32 v3 = state->v3; U32 v4 = state->v4; do { v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4; v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4; v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4; v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4; } while (p<=limit); state->v1 = v1; state->v2 = v2; state->v3 = v3; state->v4 = v4; } if (p < bEnd) { XXH_memcpy(state->mem32, p, (size_t)(bEnd-p)); state->memsize = (unsigned)(bEnd-p); } return XXH_OK; } XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len) { XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) return XXH32_update_endian(state_in, input, len, XXH_littleEndian); else return XXH32_update_endian(state_in, input, len, XXH_bigEndian); } FORCE_INLINE_TEMPLATE U32 XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian) { const BYTE * p = (const BYTE*)state->mem32; const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize; U32 h32; if (state->large_len) { h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18); } else { h32 = state->v3 /* == seed */ + PRIME32_5; } h32 += state->total_len_32; while (p+4<=bEnd) { h32 += XXH_readLE32(p, endian) * PRIME32_3; h32 = XXH_rotl32(h32, 17) * PRIME32_4; p+=4; } while (p> 15; h32 *= PRIME32_2; h32 ^= h32 >> 13; h32 *= PRIME32_3; h32 ^= h32 >> 16; return h32; } XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in) { XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) return XXH32_digest_endian(state_in, XXH_littleEndian); else return XXH32_digest_endian(state_in, XXH_bigEndian); } /* **** XXH64 **** */ FORCE_INLINE_TEMPLATE XXH_errorcode XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian) { const BYTE* p = (const BYTE*)input; const BYTE* const bEnd = p + len; #ifdef XXH_ACCEPT_NULL_INPUT_POINTER if (input==NULL) return XXH_ERROR; #endif state->total_len += len; if (state->memsize + len < 32) { /* fill in tmp buffer */ XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len); state->memsize += (U32)len; return XXH_OK; } if (state->memsize) { /* tmp buffer is full */ XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize); state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian)); state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian)); state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian)); state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian)); p += 32-state->memsize; state->memsize = 0; } if (p+32 <= bEnd) { const BYTE* const limit = bEnd - 32; U64 v1 = state->v1; U64 v2 = state->v2; U64 v3 = state->v3; U64 v4 = state->v4; do { v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8; v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8; v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8; v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8; } while (p<=limit); state->v1 = v1; state->v2 = v2; state->v3 = v3; state->v4 = v4; } if (p < bEnd) { XXH_memcpy(state->mem64, p, (size_t)(bEnd-p)); state->memsize = (unsigned)(bEnd-p); } return XXH_OK; } XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len) { XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) return XXH64_update_endian(state_in, input, len, XXH_littleEndian); else return XXH64_update_endian(state_in, input, len, XXH_bigEndian); } FORCE_INLINE_TEMPLATE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian) { const BYTE * p = (const BYTE*)state->mem64; const BYTE* const bEnd = (const BYTE*)state->mem64 + state->memsize; U64 h64; if (state->total_len >= 32) { U64 const v1 = state->v1; U64 const v2 = state->v2; U64 const v3 = state->v3; U64 const v4 = state->v4; h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18); h64 = XXH64_mergeRound(h64, v1); h64 = XXH64_mergeRound(h64, v2); h64 = XXH64_mergeRound(h64, v3); h64 = XXH64_mergeRound(h64, v4); } else { h64 = state->v3 + PRIME64_5; } h64 += (U64) state->total_len; while (p+8<=bEnd) { U64 const k1 = XXH64_round(0, XXH_readLE64(p, endian)); h64 ^= k1; h64 = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; p+=8; } if (p+4<=bEnd) { h64 ^= (U64)(XXH_readLE32(p, endian)) * PRIME64_1; h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3; p+=4; } while (p> 33; h64 *= PRIME64_2; h64 ^= h64 >> 29; h64 *= PRIME64_3; h64 ^= h64 >> 32; return h64; } XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in) { XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) return XXH64_digest_endian(state_in, XXH_littleEndian); else return XXH64_digest_endian(state_in, XXH_bigEndian); } /* ************************** * Canonical representation ****************************/ /*! Default XXH result types are basic unsigned 32 and 64 bits. * The canonical representation follows human-readable write convention, aka big-endian (large digits first). * These functions allow transformation of hash result into and from its canonical format. * This way, hash values can be written into a file or buffer, and remain comparable across different systems and programs. */ XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash) { XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t)); if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash); memcpy(dst, &hash, sizeof(*dst)); } XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash) { XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t)); if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash); memcpy(dst, &hash, sizeof(*dst)); } XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src) { return XXH_readBE32(src); } XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src) { return XXH_readBE64(src); } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/xxhash.h ================================================ /* xxHash - Extremely Fast Hash algorithm Header File Copyright (C) 2012-2016, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - xxHash source repository : https://github.com/Cyan4973/xxHash */ /* Notice extracted from xxHash homepage : xxHash is an extremely fast Hash algorithm, running at RAM speed limits. It also successfully passes all tests from the SMHasher suite. Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz) Name Speed Q.Score Author xxHash 5.4 GB/s 10 CrapWow 3.2 GB/s 2 Andrew MumurHash 3a 2.7 GB/s 10 Austin Appleby SpookyHash 2.0 GB/s 10 Bob Jenkins SBox 1.4 GB/s 9 Bret Mulvey Lookup3 1.2 GB/s 9 Bob Jenkins SuperFastHash 1.2 GB/s 1 Paul Hsieh CityHash64 1.05 GB/s 10 Pike & Alakuijala FNV 0.55 GB/s 5 Fowler, Noll, Vo CRC32 0.43 GB/s 9 MD5-32 0.33 GB/s 10 Ronald L. Rivest SHA1-32 0.28 GB/s 10 Q.Score is a measure of quality of the hash function. It depends on successfully passing SMHasher test set. 10 is a perfect score. A 64-bits version, named XXH64, is available since r35. It offers much better speed, but for 64-bits applications only. Name Speed on 64 bits Speed on 32 bits XXH64 13.8 GB/s 1.9 GB/s XXH32 6.8 GB/s 6.0 GB/s */ #if defined (__cplusplus) extern "C" { #endif #ifndef XXHASH_H_5627135585666179 #define XXHASH_H_5627135585666179 1 /* **************************** * Definitions ******************************/ #include /* size_t */ typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode; /* **************************** * API modifier ******************************/ /** XXH_PRIVATE_API * This is useful if you want to include xxhash functions in `static` mode * in order to inline them, and remove their symbol from the public list. * Methodology : * #define XXH_PRIVATE_API * #include "xxhash.h" * `xxhash.c` is automatically included. * It's not useful to compile and link it as a separate module anymore. */ #ifdef XXH_PRIVATE_API # ifndef XXH_STATIC_LINKING_ONLY # define XXH_STATIC_LINKING_ONLY # endif # if defined(__GNUC__) # define XXH_PUBLIC_API static __inline __attribute__((unused)) # elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) # define XXH_PUBLIC_API static inline # elif defined(_MSC_VER) # define XXH_PUBLIC_API static __inline # else # define XXH_PUBLIC_API static /* this version may generate warnings for unused static functions; disable the relevant warning */ # endif #else # define XXH_PUBLIC_API /* do nothing */ #endif /* XXH_PRIVATE_API */ /*!XXH_NAMESPACE, aka Namespace Emulation : If you want to include _and expose_ xxHash functions from within your own library, but also want to avoid symbol collisions with another library which also includes xxHash, you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library with the value of XXH_NAMESPACE (so avoid to keep it NULL and avoid numeric values). Note that no change is required within the calling program as long as it includes `xxhash.h` : regular symbol name will be automatically translated by this header. */ #ifdef XXH_NAMESPACE # define XXH_CAT(A,B) A##B # define XXH_NAME2(A,B) XXH_CAT(A,B) # define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32) # define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64) # define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber) # define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState) # define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState) # define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState) # define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState) # define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset) # define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset) # define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update) # define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update) # define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest) # define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest) # define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState) # define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState) # define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash) # define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash) # define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical) # define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical) #endif /* ************************************* * Version ***************************************/ #define XXH_VERSION_MAJOR 0 #define XXH_VERSION_MINOR 6 #define XXH_VERSION_RELEASE 2 #define XXH_VERSION_NUMBER (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE) XXH_PUBLIC_API unsigned XXH_versionNumber (void); /* **************************** * Simple Hash Functions ******************************/ typedef unsigned int XXH32_hash_t; typedef unsigned long long XXH64_hash_t; XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed); XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed); /*! XXH32() : Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input". The memory between input & input+length must be valid (allocated and read-accessible). "seed" can be used to alter the result predictably. Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s XXH64() : Calculate the 64-bits hash of sequence of length "len" stored at memory address "input". "seed" can be used to alter the result predictably. This function runs 2x faster on 64-bits systems, but slower on 32-bits systems (see benchmark). */ /* **************************** * Streaming Hash Functions ******************************/ typedef struct XXH32_state_s XXH32_state_t; /* incomplete type */ typedef struct XXH64_state_s XXH64_state_t; /* incomplete type */ /*! State allocation, compatible with dynamic libraries */ XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void); XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr); XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void); XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr); /* hash streaming */ XXH_PUBLIC_API XXH_errorcode XXH32_reset (XXH32_state_t* statePtr, unsigned int seed); XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length); XXH_PUBLIC_API XXH32_hash_t XXH32_digest (const XXH32_state_t* statePtr); XXH_PUBLIC_API XXH_errorcode XXH64_reset (XXH64_state_t* statePtr, unsigned long long seed); XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length); XXH_PUBLIC_API XXH64_hash_t XXH64_digest (const XXH64_state_t* statePtr); /* These functions generate the xxHash of an input provided in multiple segments. Note that, for small input, they are slower than single-call functions, due to state management. For small input, prefer `XXH32()` and `XXH64()` . XXH state must first be allocated, using XXH*_createState() . Start a new hash by initializing state with a seed, using XXH*_reset(). Then, feed the hash state by calling XXH*_update() as many times as necessary. Obviously, input must be allocated and read accessible. The function returns an error code, with 0 meaning OK, and any other value meaning there is an error. Finally, a hash value can be produced anytime, by using XXH*_digest(). This function returns the nn-bits hash as an int or long long. It's still possible to continue inserting input into the hash state after a digest, and generate some new hashes later on, by calling again XXH*_digest(). When done, free XXH state space if it was allocated dynamically. */ /* ************************** * Utils ****************************/ #if !(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) /* ! C99 */ # define restrict /* disable restrict */ #endif XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* restrict dst_state, const XXH32_state_t* restrict src_state); XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* restrict dst_state, const XXH64_state_t* restrict src_state); /* ************************** * Canonical representation ****************************/ /* Default result type for XXH functions are primitive unsigned 32 and 64 bits. * The canonical representation uses human-readable write convention, aka big-endian (large digits first). * These functions allow transformation of hash result into and from its canonical format. * This way, hash values can be written into a file / memory, and remain comparable on different systems and programs. */ typedef struct { unsigned char digest[4]; } XXH32_canonical_t; typedef struct { unsigned char digest[8]; } XXH64_canonical_t; XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash); XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash); XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src); XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src); #endif /* XXHASH_H_5627135585666179 */ /* ================================================================================================ This section contains definitions which are not guaranteed to remain stable. They may change in future versions, becoming incompatible with a different version of the library. They shall only be used with static linking. Never use these definitions in association with dynamic linking ! =================================================================================================== */ #if defined(XXH_STATIC_LINKING_ONLY) && !defined(XXH_STATIC_H_3543687687345) #define XXH_STATIC_H_3543687687345 /* These definitions are only meant to allow allocation of XXH state statically, on stack, or in a struct for example. Do not use members directly. */ struct XXH32_state_s { unsigned total_len_32; unsigned large_len; unsigned v1; unsigned v2; unsigned v3; unsigned v4; unsigned mem32[4]; /* buffer defined as U32 for alignment */ unsigned memsize; unsigned reserved; /* never read nor write, will be removed in a future version */ }; /* typedef'd to XXH32_state_t */ struct XXH64_state_s { unsigned long long total_len; unsigned long long v1; unsigned long long v2; unsigned long long v3; unsigned long long v4; unsigned long long mem64[4]; /* buffer defined as U64 for alignment */ unsigned memsize; unsigned reserved[2]; /* never read nor write, will be removed in a future version */ }; /* typedef'd to XXH64_state_t */ # ifdef XXH_PRIVATE_API # include "xxhash.c" /* include xxhash functions as `static`, for inlining */ # endif #endif /* XXH_STATIC_LINKING_ONLY && XXH_STATIC_H_3543687687345 */ #if defined (__cplusplus) } #endif ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zbuff.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /* *************************************************************** * NOTES/WARNINGS ******************************************************************/ /* The streaming API defined here is deprecated. * Consider migrating towards ZSTD_compressStream() API in `zstd.h` * See 'lib/README.md'. *****************************************************************/ #if defined (__cplusplus) extern "C" { #endif #ifndef ZSTD_BUFFERED_H_23987 #define ZSTD_BUFFERED_H_23987 /* ************************************* * Dependencies ***************************************/ #include /* size_t */ #include "zstd.h" /* ZSTD_CStream, ZSTD_DStream, ZSTDLIB_API */ /* *************************************************************** * Compiler specifics *****************************************************************/ /* Deprecation warnings */ /* Should these warnings be a problem, it is generally possible to disable them, typically with -Wno-deprecated-declarations for gcc or _CRT_SECURE_NO_WARNINGS in Visual. Otherwise, it's also possible to define ZBUFF_DISABLE_DEPRECATE_WARNINGS */ #ifdef ZBUFF_DISABLE_DEPRECATE_WARNINGS # define ZBUFF_DEPRECATED(message) ZSTDLIB_API /* disable deprecation warnings */ #else # if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */ # define ZBUFF_DEPRECATED(message) [[deprecated(message)]] ZSTDLIB_API # elif (defined(__GNUC__) && (__GNUC__ >= 5)) || defined(__clang__) # define ZBUFF_DEPRECATED(message) ZSTDLIB_API __attribute__((deprecated(message))) # elif defined(__GNUC__) && (__GNUC__ >= 3) # define ZBUFF_DEPRECATED(message) ZSTDLIB_API __attribute__((deprecated)) # elif defined(_MSC_VER) # define ZBUFF_DEPRECATED(message) ZSTDLIB_API __declspec(deprecated(message)) # else # pragma message("WARNING: You need to implement ZBUFF_DEPRECATED for this compiler") # define ZBUFF_DEPRECATED(message) ZSTDLIB_API # endif #endif /* ZBUFF_DISABLE_DEPRECATE_WARNINGS */ /* ************************************* * Streaming functions ***************************************/ /* This is the easier "buffered" streaming API, * using an internal buffer to lift all restrictions on user-provided buffers * which can be any size, any place, for both input and output. * ZBUFF and ZSTD are 100% interoperable, * frames created by one can be decoded by the other one */ typedef ZSTD_CStream ZBUFF_CCtx; ZBUFF_DEPRECATED("use ZSTD_createCStream") ZBUFF_CCtx* ZBUFF_createCCtx(void); ZBUFF_DEPRECATED("use ZSTD_freeCStream") size_t ZBUFF_freeCCtx(ZBUFF_CCtx* cctx); ZBUFF_DEPRECATED("use ZSTD_initCStream") size_t ZBUFF_compressInit(ZBUFF_CCtx* cctx, int compressionLevel); ZBUFF_DEPRECATED("use ZSTD_initCStream_usingDict") size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel); ZBUFF_DEPRECATED("use ZSTD_compressStream") size_t ZBUFF_compressContinue(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr, const void* src, size_t* srcSizePtr); ZBUFF_DEPRECATED("use ZSTD_flushStream") size_t ZBUFF_compressFlush(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr); ZBUFF_DEPRECATED("use ZSTD_endStream") size_t ZBUFF_compressEnd(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr); /*-************************************************* * Streaming compression - howto * * A ZBUFF_CCtx object is required to track streaming operation. * Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources. * ZBUFF_CCtx objects can be reused multiple times. * * Start by initializing ZBUF_CCtx. * Use ZBUFF_compressInit() to start a new compression operation. * Use ZBUFF_compressInitDictionary() for a compression which requires a dictionary. * * Use ZBUFF_compressContinue() repetitively to consume input stream. * *srcSizePtr and *dstCapacityPtr can be any size. * The function will report how many bytes were read or written within *srcSizePtr and *dstCapacityPtr. * Note that it may not consume the entire input, in which case it's up to the caller to present again remaining data. * The content of `dst` will be overwritten (up to *dstCapacityPtr) at each call, so save its content if it matters or change @dst . * @return : a hint to preferred nb of bytes to use as input for next function call (it's just a hint, to improve latency) * or an error code, which can be tested using ZBUFF_isError(). * * At any moment, it's possible to flush whatever data remains within buffer, using ZBUFF_compressFlush(). * The nb of bytes written into `dst` will be reported into *dstCapacityPtr. * Note that the function cannot output more than *dstCapacityPtr, * therefore, some content might still be left into internal buffer if *dstCapacityPtr is too small. * @return : nb of bytes still present into internal buffer (0 if it's empty) * or an error code, which can be tested using ZBUFF_isError(). * * ZBUFF_compressEnd() instructs to finish a frame. * It will perform a flush and write frame epilogue. * The epilogue is required for decoders to consider a frame completed. * Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small. * In which case, call again ZBUFF_compressFlush() to complete the flush. * @return : nb of bytes still present into internal buffer (0 if it's empty) * or an error code, which can be tested using ZBUFF_isError(). * * Hint : _recommended buffer_ sizes (not compulsory) : ZBUFF_recommendedCInSize() / ZBUFF_recommendedCOutSize() * input : ZBUFF_recommendedCInSize==128 KB block size is the internal unit, use this value to reduce intermediate stages (better latency) * output : ZBUFF_recommendedCOutSize==ZSTD_compressBound(128 KB) + 3 + 3 : ensures it's always possible to write/flush/end a full block. Skip some buffering. * By using both, it ensures that input will be entirely consumed, and output will always contain the result, reducing intermediate buffering. * **************************************************/ typedef ZSTD_DStream ZBUFF_DCtx; ZBUFF_DEPRECATED("use ZSTD_createDStream") ZBUFF_DCtx* ZBUFF_createDCtx(void); ZBUFF_DEPRECATED("use ZSTD_freeDStream") size_t ZBUFF_freeDCtx(ZBUFF_DCtx* dctx); ZBUFF_DEPRECATED("use ZSTD_initDStream") size_t ZBUFF_decompressInit(ZBUFF_DCtx* dctx); ZBUFF_DEPRECATED("use ZSTD_initDStream_usingDict") size_t ZBUFF_decompressInitDictionary(ZBUFF_DCtx* dctx, const void* dict, size_t dictSize); ZBUFF_DEPRECATED("use ZSTD_decompressStream") size_t ZBUFF_decompressContinue(ZBUFF_DCtx* dctx, void* dst, size_t* dstCapacityPtr, const void* src, size_t* srcSizePtr); /*-*************************************************************************** * Streaming decompression howto * * A ZBUFF_DCtx object is required to track streaming operations. * Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources. * Use ZBUFF_decompressInit() to start a new decompression operation, * or ZBUFF_decompressInitDictionary() if decompression requires a dictionary. * Note that ZBUFF_DCtx objects can be re-init multiple times. * * Use ZBUFF_decompressContinue() repetitively to consume your input. * *srcSizePtr and *dstCapacityPtr can be any size. * The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr. * Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again. * The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`. * @return : 0 when a frame is completely decoded and fully flushed, * 1 when there is still some data left within internal buffer to flush, * >1 when more data is expected, with value being a suggested next input size (it's just a hint, which helps latency), * or an error code, which can be tested using ZBUFF_isError(). * * Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize() and ZBUFF_recommendedDOutSize() * output : ZBUFF_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded. * input : ZBUFF_recommendedDInSize == 128KB + 3; * just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 . * *******************************************************************************/ /* ************************************* * Tool functions ***************************************/ ZBUFF_DEPRECATED("use ZSTD_isError") unsigned ZBUFF_isError(size_t errorCode); ZBUFF_DEPRECATED("use ZSTD_getErrorName") const char* ZBUFF_getErrorName(size_t errorCode); /** Functions below provide recommended buffer sizes for Compression or Decompression operations. * These sizes are just hints, they tend to offer better latency */ ZBUFF_DEPRECATED("use ZSTD_CStreamInSize") size_t ZBUFF_recommendedCInSize(void); ZBUFF_DEPRECATED("use ZSTD_CStreamOutSize") size_t ZBUFF_recommendedCOutSize(void); ZBUFF_DEPRECATED("use ZSTD_DStreamInSize") size_t ZBUFF_recommendedDInSize(void); ZBUFF_DEPRECATED("use ZSTD_DStreamOutSize") size_t ZBUFF_recommendedDOutSize(void); #endif /* ZSTD_BUFFERED_H_23987 */ #ifdef ZBUFF_STATIC_LINKING_ONLY #ifndef ZBUFF_STATIC_H_30298098432 #define ZBUFF_STATIC_H_30298098432 /* ==================================================================================== * The definitions in this section are considered experimental. * They should never be used in association with a dynamic library, as they may change in the future. * They are provided for advanced usages. * Use them only in association with static linking. * ==================================================================================== */ /*--- Dependency ---*/ #define ZSTD_STATIC_LINKING_ONLY /* ZSTD_parameters, ZSTD_customMem */ #include "zstd.h" /*--- Custom memory allocator ---*/ /*! ZBUFF_createCCtx_advanced() : * Create a ZBUFF compression context using external alloc and free functions */ ZBUFF_DEPRECATED("use ZSTD_createCStream_advanced") ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem); /*! ZBUFF_createDCtx_advanced() : * Create a ZBUFF decompression context using external alloc and free functions */ ZBUFF_DEPRECATED("use ZSTD_createDStream_advanced") ZBUFF_DCtx* ZBUFF_createDCtx_advanced(ZSTD_customMem customMem); /*--- Advanced Streaming Initialization ---*/ ZBUFF_DEPRECATED("use ZSTD_initDStream_usingDict") size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); #endif /* ZBUFF_STATIC_H_30298098432 */ #endif /* ZBUFF_STATIC_LINKING_ONLY */ #if defined (__cplusplus) } #endif ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zbuff_common.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /*-************************************* * Dependencies ***************************************/ #include "error_private.h" #include "zbuff.h" /*-**************************************** * ZBUFF Error Management (deprecated) ******************************************/ /*! ZBUFF_isError() : * tells if a return value is an error code */ unsigned ZBUFF_isError(size_t errorCode) { return ERR_isError(errorCode); } /*! ZBUFF_getErrorName() : * provides error code string from function result (useful for debugging) */ const char* ZBUFF_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zbuff_compress.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /* ************************************* * Dependencies ***************************************/ #define ZBUFF_STATIC_LINKING_ONLY #include "zbuff.h" /*-*********************************************************** * Streaming compression * * A ZBUFF_CCtx object is required to track streaming operation. * Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources. * Use ZBUFF_compressInit() to start a new compression operation. * ZBUFF_CCtx objects can be reused multiple times. * * Use ZBUFF_compressContinue() repetitively to consume your input. * *srcSizePtr and *dstCapacityPtr can be any size. * The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr. * Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input. * The content of dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change dst . * @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency) * or an error code, which can be tested using ZBUFF_isError(). * * ZBUFF_compressFlush() can be used to instruct ZBUFF to compress and output whatever remains within its buffer. * Note that it will not output more than *dstCapacityPtr. * Therefore, some content might still be left into its internal buffer if dst buffer is too small. * @return : nb of bytes still present into internal buffer (0 if it's empty) * or an error code, which can be tested using ZBUFF_isError(). * * ZBUFF_compressEnd() instructs to finish a frame. * It will perform a flush and write frame epilogue. * Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small. * @return : nb of bytes still present into internal buffer (0 if it's empty) * or an error code, which can be tested using ZBUFF_isError(). * * Hint : recommended buffer sizes (not compulsory) * input : ZSTD_BLOCKSIZE_MAX (128 KB), internal unit size, it improves latency to use this value. * output : ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + ZBUFF_endFrameSize : ensures it's always possible to write/flush/end a full block at best speed. * ***********************************************************/ ZBUFF_CCtx* ZBUFF_createCCtx(void) { return ZSTD_createCStream(); } ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem) { return ZSTD_createCStream_advanced(customMem); } size_t ZBUFF_freeCCtx(ZBUFF_CCtx* zbc) { return ZSTD_freeCStream(zbc); } /* ====== Initialization ====== */ size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize) { if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN; /* preserve "0 == unknown" behavior */ return ZSTD_initCStream_advanced(zbc, dict, dictSize, params, pledgedSrcSize); } size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, int compressionLevel) { return ZSTD_initCStream_usingDict(zbc, dict, dictSize, compressionLevel); } size_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel) { return ZSTD_initCStream(zbc, compressionLevel); } /* ====== Compression ====== */ size_t ZBUFF_compressContinue(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr, const void* src, size_t* srcSizePtr) { size_t result; ZSTD_outBuffer outBuff; ZSTD_inBuffer inBuff; outBuff.dst = dst; outBuff.pos = 0; outBuff.size = *dstCapacityPtr; inBuff.src = src; inBuff.pos = 0; inBuff.size = *srcSizePtr; result = ZSTD_compressStream(zbc, &outBuff, &inBuff); *dstCapacityPtr = outBuff.pos; *srcSizePtr = inBuff.pos; return result; } /* ====== Finalize ====== */ size_t ZBUFF_compressFlush(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr) { size_t result; ZSTD_outBuffer outBuff; outBuff.dst = dst; outBuff.pos = 0; outBuff.size = *dstCapacityPtr; result = ZSTD_flushStream(zbc, &outBuff); *dstCapacityPtr = outBuff.pos; return result; } size_t ZBUFF_compressEnd(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr) { size_t result; ZSTD_outBuffer outBuff; outBuff.dst = dst; outBuff.pos = 0; outBuff.size = *dstCapacityPtr; result = ZSTD_endStream(zbc, &outBuff); *dstCapacityPtr = outBuff.pos; return result; } /* ************************************* * Tool functions ***************************************/ size_t ZBUFF_recommendedCInSize(void) { return ZSTD_CStreamInSize(); } size_t ZBUFF_recommendedCOutSize(void) { return ZSTD_CStreamOutSize(); } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zbuff_decompress.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /* ************************************* * Dependencies ***************************************/ #define ZBUFF_STATIC_LINKING_ONLY #include "zbuff.h" ZBUFF_DCtx* ZBUFF_createDCtx(void) { return ZSTD_createDStream(); } ZBUFF_DCtx* ZBUFF_createDCtx_advanced(ZSTD_customMem customMem) { return ZSTD_createDStream_advanced(customMem); } size_t ZBUFF_freeDCtx(ZBUFF_DCtx* zbd) { return ZSTD_freeDStream(zbd); } /* *** Initialization *** */ size_t ZBUFF_decompressInitDictionary(ZBUFF_DCtx* zbd, const void* dict, size_t dictSize) { return ZSTD_initDStream_usingDict(zbd, dict, dictSize); } size_t ZBUFF_decompressInit(ZBUFF_DCtx* zbd) { return ZSTD_initDStream(zbd); } /* *** Decompression *** */ size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbd, void* dst, size_t* dstCapacityPtr, const void* src, size_t* srcSizePtr) { ZSTD_outBuffer outBuff; ZSTD_inBuffer inBuff; size_t result; outBuff.dst = dst; outBuff.pos = 0; outBuff.size = *dstCapacityPtr; inBuff.src = src; inBuff.pos = 0; inBuff.size = *srcSizePtr; result = ZSTD_decompressStream(zbd, &outBuff, &inBuff); *dstCapacityPtr = outBuff.pos; *srcSizePtr = inBuff.pos; return result; } /* ************************************* * Tool functions ***************************************/ size_t ZBUFF_recommendedDInSize(void) { return ZSTD_DStreamInSize(); } size_t ZBUFF_recommendedDOutSize(void) { return ZSTD_DStreamOutSize(); } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zdict.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /*-************************************** * Tuning parameters ****************************************/ #define MINRATIO 4 /* minimum nb of apparition to be selected in dictionary */ #define ZDICT_MAX_SAMPLES_SIZE (2000U << 20) #define ZDICT_MIN_SAMPLES_SIZE (ZDICT_CONTENTSIZE_MIN * MINRATIO) /*-************************************** * Compiler Options ****************************************/ /* Unix Large Files support (>4GB) */ #define _FILE_OFFSET_BITS 64 #if (defined(__sun__) && (!defined(__LP64__))) /* Sun Solaris 32-bits requires specific definitions */ # define _LARGEFILE_SOURCE #elif ! defined(__LP64__) /* No point defining Large file for 64 bit */ # define _LARGEFILE64_SOURCE #endif /*-************************************* * Dependencies ***************************************/ #include /* malloc, free */ #include /* memset */ #include /* fprintf, fopen, ftello64 */ #include /* clock */ #include "mem.h" /* read */ #include "fse.h" /* FSE_normalizeCount, FSE_writeNCount */ #define HUF_STATIC_LINKING_ONLY #include "huf.h" /* HUF_buildCTable, HUF_writeCTable */ #include "zstd_internal.h" /* includes zstd.h */ #include "xxhash.h" /* XXH64 */ #include "divsufsort.h" #ifndef ZDICT_STATIC_LINKING_ONLY # define ZDICT_STATIC_LINKING_ONLY #endif #include "zdict.h" /*-************************************* * Constants ***************************************/ #define KB *(1 <<10) #define MB *(1 <<20) #define GB *(1U<<30) #define DICTLISTSIZE_DEFAULT 10000 #define NOISELENGTH 32 static const int g_compressionLevel_default = 3; static const U32 g_selectivity_default = 9; /*-************************************* * Console display ***************************************/ #define DISPLAY(...) { fprintf(stderr, __VA_ARGS__); fflush( stderr ); } #define DISPLAYLEVEL(l, ...) if (notificationLevel>=l) { DISPLAY(__VA_ARGS__); } /* 0 : no display; 1: errors; 2: default; 3: details; 4: debug */ static clock_t ZDICT_clockSpan(clock_t nPrevious) { return clock() - nPrevious; } static void ZDICT_printHex(const void* ptr, size_t length) { const BYTE* const b = (const BYTE*)ptr; size_t u; for (u=0; u126) c = '.'; /* non-printable char */ DISPLAY("%c", c); } } /*-******************************************************** * Helper functions **********************************************************/ unsigned ZDICT_isError(size_t errorCode) { return ERR_isError(errorCode); } const char* ZDICT_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); } unsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize) { if (dictSize < 8) return 0; if (MEM_readLE32(dictBuffer) != ZSTD_MAGIC_DICTIONARY) return 0; return MEM_readLE32((const char*)dictBuffer + 4); } /*-******************************************************** * Dictionary training functions **********************************************************/ static unsigned ZDICT_NbCommonBytes (size_t val) { if (MEM_isLittleEndian()) { if (MEM_64bits()) { # if defined(_MSC_VER) && defined(_WIN64) unsigned long r = 0; _BitScanForward64( &r, (U64)val ); return (unsigned)(r>>3); # elif defined(__GNUC__) && (__GNUC__ >= 3) return (__builtin_ctzll((U64)val) >> 3); # else static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 }; return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58]; # endif } else { /* 32 bits */ # if defined(_MSC_VER) unsigned long r=0; _BitScanForward( &r, (U32)val ); return (unsigned)(r>>3); # elif defined(__GNUC__) && (__GNUC__ >= 3) return (__builtin_ctz((U32)val) >> 3); # else static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 }; return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; # endif } } else { /* Big Endian CPU */ if (MEM_64bits()) { # if defined(_MSC_VER) && defined(_WIN64) unsigned long r = 0; _BitScanReverse64( &r, val ); return (unsigned)(r>>3); # elif defined(__GNUC__) && (__GNUC__ >= 3) return (__builtin_clzll(val) >> 3); # else unsigned r; const unsigned n32 = sizeof(size_t)*4; /* calculate this way due to compiler complaining in 32-bits mode */ if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; } if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } r += (!val); return r; # endif } else { /* 32 bits */ # if defined(_MSC_VER) unsigned long r = 0; _BitScanReverse( &r, (unsigned long)val ); return (unsigned)(r>>3); # elif defined(__GNUC__) && (__GNUC__ >= 3) return (__builtin_clz((U32)val) >> 3); # else unsigned r; if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; } r += (!val); return r; # endif } } } /*! ZDICT_count() : Count the nb of common bytes between 2 pointers. Note : this function presumes end of buffer followed by noisy guard band. */ static size_t ZDICT_count(const void* pIn, const void* pMatch) { const char* const pStart = (const char*)pIn; for (;;) { size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn); if (!diff) { pIn = (const char*)pIn+sizeof(size_t); pMatch = (const char*)pMatch+sizeof(size_t); continue; } pIn = (const char*)pIn+ZDICT_NbCommonBytes(diff); return (size_t)((const char*)pIn - pStart); } } typedef struct { U32 pos; U32 length; U32 savings; } dictItem; static void ZDICT_initDictItem(dictItem* d) { d->pos = 1; d->length = 0; d->savings = (U32)(-1); } #define LLIMIT 64 /* heuristic determined experimentally */ #define MINMATCHLENGTH 7 /* heuristic determined experimentally */ static dictItem ZDICT_analyzePos( BYTE* doneMarks, const int* suffix, U32 start, const void* buffer, U32 minRatio, U32 notificationLevel) { U32 lengthList[LLIMIT] = {0}; U32 cumulLength[LLIMIT] = {0}; U32 savings[LLIMIT] = {0}; const BYTE* b = (const BYTE*)buffer; size_t maxLength = LLIMIT; size_t pos = suffix[start]; U32 end = start; dictItem solution; /* init */ memset(&solution, 0, sizeof(solution)); doneMarks[pos] = 1; /* trivial repetition cases */ if ( (MEM_read16(b+pos+0) == MEM_read16(b+pos+2)) ||(MEM_read16(b+pos+1) == MEM_read16(b+pos+3)) ||(MEM_read16(b+pos+2) == MEM_read16(b+pos+4)) ) { /* skip and mark segment */ U16 const pattern16 = MEM_read16(b+pos+4); U32 u, patternEnd = 6; while (MEM_read16(b+pos+patternEnd) == pattern16) patternEnd+=2 ; if (b[pos+patternEnd] == b[pos+patternEnd-1]) patternEnd++; for (u=1; u= MINMATCHLENGTH); } /* look backward */ { size_t length; do { length = ZDICT_count(b + pos, b + *(suffix+start-1)); if (length >=MINMATCHLENGTH) start--; } while(length >= MINMATCHLENGTH); } /* exit if not found a minimum nb of repetitions */ if (end-start < minRatio) { U32 idx; for(idx=start; idx= %i at pos %7u ", (U32)(end-start), MINMATCHLENGTH, (U32)pos); DISPLAYLEVEL(4, "\n"); for (searchLength = MINMATCHLENGTH ; ; searchLength++) { BYTE currentChar = 0; U32 currentCount = 0; U32 currentID = refinedStart; U32 id; U32 selectedCount = 0; U32 selectedID = currentID; for (id =refinedStart; id < refinedEnd; id++) { if (b[suffix[id] + searchLength] != currentChar) { if (currentCount > selectedCount) { selectedCount = currentCount; selectedID = currentID; } currentID = id; currentChar = b[ suffix[id] + searchLength]; currentCount = 0; } currentCount ++; } if (currentCount > selectedCount) { /* for last */ selectedCount = currentCount; selectedID = currentID; } if (selectedCount < minRatio) break; refinedStart = selectedID; refinedEnd = refinedStart + selectedCount; } /* evaluate gain based on new ref */ start = refinedStart; pos = suffix[refinedStart]; end = start; memset(lengthList, 0, sizeof(lengthList)); /* look forward */ { size_t length; do { end++; length = ZDICT_count(b + pos, b + suffix[end]); if (length >= LLIMIT) length = LLIMIT-1; lengthList[length]++; } while (length >=MINMATCHLENGTH); } /* look backward */ { size_t length = MINMATCHLENGTH; while ((length >= MINMATCHLENGTH) & (start > 0)) { length = ZDICT_count(b + pos, b + suffix[start - 1]); if (length >= LLIMIT) length = LLIMIT - 1; lengthList[length]++; if (length >= MINMATCHLENGTH) start--; } } /* largest useful length */ memset(cumulLength, 0, sizeof(cumulLength)); cumulLength[maxLength-1] = lengthList[maxLength-1]; for (i=(int)(maxLength-2); i>=0; i--) cumulLength[i] = cumulLength[i+1] + lengthList[i]; for (i=LLIMIT-1; i>=MINMATCHLENGTH; i--) if (cumulLength[i]>=minRatio) break; maxLength = i; /* reduce maxLength in case of final into repetitive data */ { U32 l = (U32)maxLength; BYTE const c = b[pos + maxLength-1]; while (b[pos+l-2]==c) l--; maxLength = l; } if (maxLength < MINMATCHLENGTH) return solution; /* skip : no long-enough solution */ /* calculate savings */ savings[5] = 0; for (i=MINMATCHLENGTH; i<=(int)maxLength; i++) savings[i] = savings[i-1] + (lengthList[i] * (i-3)); DISPLAYLEVEL(4, "Selected ref at position %u, of length %u : saves %u (ratio: %.2f) \n", (U32)pos, (U32)maxLength, savings[maxLength], (double)savings[maxLength] / maxLength); solution.pos = (U32)pos; solution.length = (U32)maxLength; solution.savings = savings[maxLength]; /* mark positions done */ { U32 id; for (id=start; id solution.length) length = solution.length; } pEnd = (U32)(testedPos + length); for (p=testedPos; ppos; const U32 eltEnd = elt.pos + elt.length; const char* const buf = (const char*) buffer; /* tail overlap */ U32 u; for (u=1; u elt.pos) && (table[u].pos <= eltEnd)) { /* overlap, existing > new */ /* append */ U32 const addedLength = table[u].pos - elt.pos; table[u].length += addedLength; table[u].pos = elt.pos; table[u].savings += elt.savings * addedLength / elt.length; /* rough approx */ table[u].savings += elt.length / 8; /* rough approx bonus */ elt = table[u]; /* sort : improve rank */ while ((u>1) && (table[u-1].savings < elt.savings)) table[u] = table[u-1], u--; table[u] = elt; return u; } } /* front overlap */ for (u=1; u= elt.pos) && (table[u].pos < elt.pos)) { /* overlap, existing < new */ /* append */ int const addedLength = (int)eltEnd - (table[u].pos + table[u].length); table[u].savings += elt.length / 8; /* rough approx bonus */ if (addedLength > 0) { /* otherwise, elt fully included into existing */ table[u].length += addedLength; table[u].savings += elt.savings * addedLength / elt.length; /* rough approx */ } /* sort : improve rank */ elt = table[u]; while ((u>1) && (table[u-1].savings < elt.savings)) table[u] = table[u-1], u--; table[u] = elt; return u; } if (MEM_read64(buf + table[u].pos) == MEM_read64(buf + elt.pos + 1)) { if (isIncluded(buf + table[u].pos, buf + elt.pos + 1, table[u].length)) { size_t const addedLength = MAX( (int)elt.length - (int)table[u].length , 1 ); table[u].pos = elt.pos; table[u].savings += (U32)(elt.savings * addedLength / elt.length); table[u].length = MIN(elt.length, table[u].length + 1); return u; } } } return 0; } static void ZDICT_removeDictItem(dictItem* table, U32 id) { /* convention : table[0].pos stores nb of elts */ U32 const max = table[0].pos; U32 u; if (!id) return; /* protection, should never happen */ for (u=id; upos--; } static void ZDICT_insertDictItem(dictItem* table, U32 maxSize, dictItem elt, const void* buffer) { /* merge if possible */ U32 mergeId = ZDICT_tryMerge(table, elt, 0, buffer); if (mergeId) { U32 newMerge = 1; while (newMerge) { newMerge = ZDICT_tryMerge(table, table[mergeId], mergeId, buffer); if (newMerge) ZDICT_removeDictItem(table, mergeId); mergeId = newMerge; } return; } /* insert */ { U32 current; U32 nextElt = table->pos; if (nextElt >= maxSize) nextElt = maxSize-1; current = nextElt-1; while (table[current].savings < elt.savings) { table[current+1] = table[current]; current--; } table[current+1] = elt; table->pos = nextElt+1; } } static U32 ZDICT_dictSize(const dictItem* dictList) { U32 u, dictSize = 0; for (u=1; u=l) { \ if (ZDICT_clockSpan(displayClock) > refreshRate) \ { displayClock = clock(); DISPLAY(__VA_ARGS__); \ if (notificationLevel>=4) fflush(stderr); } } /* init */ DISPLAYLEVEL(2, "\r%70s\r", ""); /* clean display line */ if (!suffix0 || !reverseSuffix || !doneMarks || !filePos) { result = ERROR(memory_allocation); goto _cleanup; } if (minRatio < MINRATIO) minRatio = MINRATIO; memset(doneMarks, 0, bufferSize+16); /* limit sample set size (divsufsort limitation)*/ if (bufferSize > ZDICT_MAX_SAMPLES_SIZE) DISPLAYLEVEL(3, "sample set too large : reduced to %u MB ...\n", (U32)(ZDICT_MAX_SAMPLES_SIZE>>20)); while (bufferSize > ZDICT_MAX_SAMPLES_SIZE) bufferSize -= fileSizes[--nbFiles]; /* sort */ DISPLAYLEVEL(2, "sorting %u files of total size %u MB ...\n", nbFiles, (U32)(bufferSize>>20)); { int const divSuftSortResult = divsufsort((const unsigned char*)buffer, suffix, (int)bufferSize, 0); if (divSuftSortResult != 0) { result = ERROR(GENERIC); goto _cleanup; } } suffix[bufferSize] = (int)bufferSize; /* leads into noise */ suffix0[0] = (int)bufferSize; /* leads into noise */ /* build reverse suffix sort */ { size_t pos; for (pos=0; pos < bufferSize; pos++) reverseSuffix[suffix[pos]] = (U32)pos; /* note filePos tracks borders between samples. It's not used at this stage, but planned to become useful in a later update */ filePos[0] = 0; for (pos=1; pos> 21); } } typedef struct { ZSTD_CCtx* ref; /* contains reference to dictionary */ ZSTD_CCtx* zc; /* working context */ void* workPlace; /* must be ZSTD_BLOCKSIZE_MAX allocated */ } EStats_ress_t; #define MAXREPOFFSET 1024 static void ZDICT_countEStats(EStats_ress_t esr, ZSTD_parameters params, U32* countLit, U32* offsetcodeCount, U32* matchlengthCount, U32* litlengthCount, U32* repOffsets, const void* src, size_t srcSize, U32 notificationLevel) { size_t const blockSizeMax = MIN (ZSTD_BLOCKSIZE_MAX, 1 << params.cParams.windowLog); size_t cSize; if (srcSize > blockSizeMax) srcSize = blockSizeMax; /* protection vs large samples */ { size_t const errorCode = ZSTD_copyCCtx(esr.zc, esr.ref, 0); if (ZSTD_isError(errorCode)) { DISPLAYLEVEL(1, "warning : ZSTD_copyCCtx failed \n"); return; } } cSize = ZSTD_compressBlock(esr.zc, esr.workPlace, ZSTD_BLOCKSIZE_MAX, src, srcSize); if (ZSTD_isError(cSize)) { DISPLAYLEVEL(3, "warning : could not compress sample size %u \n", (U32)srcSize); return; } if (cSize) { /* if == 0; block is not compressible */ const seqStore_t* const seqStorePtr = ZSTD_getSeqStore(esr.zc); /* literals stats */ { const BYTE* bytePtr; for(bytePtr = seqStorePtr->litStart; bytePtr < seqStorePtr->lit; bytePtr++) countLit[*bytePtr]++; } /* seqStats */ { U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart); ZSTD_seqToCodes(seqStorePtr); { const BYTE* codePtr = seqStorePtr->ofCode; U32 u; for (u=0; umlCode; U32 u; for (u=0; ullCode; U32 u; for (u=0; u= 2) { /* rep offsets */ const seqDef* const seq = seqStorePtr->sequencesStart; U32 offset1 = seq[0].offset - 3; U32 offset2 = seq[1].offset - 3; if (offset1 >= MAXREPOFFSET) offset1 = 0; if (offset2 >= MAXREPOFFSET) offset2 = 0; repOffsets[offset1] += 3; repOffsets[offset2] += 1; } } } } static size_t ZDICT_totalSampleSize(const size_t* fileSizes, unsigned nbFiles) { size_t total=0; unsigned u; for (u=0; u0; u--) { offsetCount_t tmp; if (table[u-1].count >= table[u].count) break; tmp = table[u-1]; table[u-1] = table[u]; table[u] = tmp; } } /* ZDICT_flatLit() : * rewrite `countLit` to contain a mostly flat but still compressible distribution of literals. * necessary to avoid generating a non-compressible distribution that HUF_writeCTable() cannot encode. */ static void ZDICT_flatLit(U32* countLit) { int u; for (u=1; u<256; u++) countLit[u] = 2; countLit[0] = 4; countLit[253] = 1; countLit[254] = 1; } #define OFFCODE_MAX 30 /* only applicable to first block */ static size_t ZDICT_analyzeEntropy(void* dstBuffer, size_t maxDstSize, unsigned compressionLevel, const void* srcBuffer, const size_t* fileSizes, unsigned nbFiles, const void* dictBuffer, size_t dictBufferSize, unsigned notificationLevel) { U32 countLit[256]; HUF_CREATE_STATIC_CTABLE(hufTable, 255); U32 offcodeCount[OFFCODE_MAX+1]; short offcodeNCount[OFFCODE_MAX+1]; U32 offcodeMax = ZSTD_highbit32((U32)(dictBufferSize + 128 KB)); U32 matchLengthCount[MaxML+1]; short matchLengthNCount[MaxML+1]; U32 litLengthCount[MaxLL+1]; short litLengthNCount[MaxLL+1]; U32 repOffset[MAXREPOFFSET]; offsetCount_t bestRepOffset[ZSTD_REP_NUM+1]; EStats_ress_t esr; ZSTD_parameters params; U32 u, huffLog = 11, Offlog = OffFSELog, mlLog = MLFSELog, llLog = LLFSELog, total; size_t pos = 0, errorCode; size_t eSize = 0; size_t const totalSrcSize = ZDICT_totalSampleSize(fileSizes, nbFiles); size_t const averageSampleSize = totalSrcSize / (nbFiles + !nbFiles); BYTE* dstPtr = (BYTE*)dstBuffer; /* init */ DEBUGLOG(4, "ZDICT_analyzeEntropy"); esr.ref = ZSTD_createCCtx(); esr.zc = ZSTD_createCCtx(); esr.workPlace = malloc(ZSTD_BLOCKSIZE_MAX); if (!esr.ref || !esr.zc || !esr.workPlace) { eSize = ERROR(memory_allocation); DISPLAYLEVEL(1, "Not enough memory \n"); goto _cleanup; } if (offcodeMax>OFFCODE_MAX) { eSize = ERROR(dictionaryCreation_failed); goto _cleanup; } /* too large dictionary */ for (u=0; u<256; u++) countLit[u] = 1; /* any character must be described */ for (u=0; u<=offcodeMax; u++) offcodeCount[u] = 1; for (u=0; u<=MaxML; u++) matchLengthCount[u] = 1; for (u=0; u<=MaxLL; u++) litLengthCount[u] = 1; memset(repOffset, 0, sizeof(repOffset)); repOffset[1] = repOffset[4] = repOffset[8] = 1; memset(bestRepOffset, 0, sizeof(bestRepOffset)); if (compressionLevel<=0) compressionLevel = g_compressionLevel_default; params = ZSTD_getParams(compressionLevel, averageSampleSize, dictBufferSize); { size_t const beginResult = ZSTD_compressBegin_advanced(esr.ref, dictBuffer, dictBufferSize, params, 0); if (ZSTD_isError(beginResult)) { DISPLAYLEVEL(1, "error : ZSTD_compressBegin_advanced() failed : %s \n", ZSTD_getErrorName(beginResult)); eSize = ERROR(GENERIC); goto _cleanup; } } /* collect stats on all samples */ for (u=0; u dictBufferCapacity) dictContentSize = dictBufferCapacity - hSize; { size_t const dictSize = hSize + dictContentSize; char* dictEnd = (char*)dictBuffer + dictSize; memmove(dictEnd - dictContentSize, customDictContent, dictContentSize); memcpy(dictBuffer, header, hSize); return dictSize; } } size_t ZDICT_addEntropyTablesFromBuffer_advanced(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, ZDICT_params_t params) { int const compressionLevel = (params.compressionLevel <= 0) ? g_compressionLevel_default : params.compressionLevel; U32 const notificationLevel = params.notificationLevel; size_t hSize = 8; /* calculate entropy tables */ DISPLAYLEVEL(2, "\r%70s\r", ""); /* clean display line */ DISPLAYLEVEL(2, "statistics ... \n"); { size_t const eSize = ZDICT_analyzeEntropy((char*)dictBuffer+hSize, dictBufferCapacity-hSize, compressionLevel, samplesBuffer, samplesSizes, nbSamples, (char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize, notificationLevel); if (ZDICT_isError(eSize)) return eSize; hSize += eSize; } /* add dictionary header (after entropy tables) */ MEM_writeLE32(dictBuffer, ZSTD_MAGIC_DICTIONARY); { U64 const randomID = XXH64((char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize, 0); U32 const compliantID = (randomID % ((1U<<31)-32768)) + 32768; U32 const dictID = params.dictID ? params.dictID : compliantID; MEM_writeLE32((char*)dictBuffer+4, dictID); } if (hSize + dictContentSize < dictBufferCapacity) memmove((char*)dictBuffer + hSize, (char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize); return MIN(dictBufferCapacity, hSize+dictContentSize); } /*! ZDICT_trainFromBuffer_unsafe_legacy() : * Warning : `samplesBuffer` must be followed by noisy guard band. * @return : size of dictionary, or an error code which can be tested with ZDICT_isError() */ size_t ZDICT_trainFromBuffer_unsafe_legacy( void* dictBuffer, size_t maxDictSize, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, ZDICT_legacy_params_t params) { U32 const dictListSize = MAX(MAX(DICTLISTSIZE_DEFAULT, nbSamples), (U32)(maxDictSize/16)); dictItem* const dictList = (dictItem*)malloc(dictListSize * sizeof(*dictList)); unsigned const selectivity = params.selectivityLevel == 0 ? g_selectivity_default : params.selectivityLevel; unsigned const minRep = (selectivity > 30) ? MINRATIO : nbSamples >> selectivity; size_t const targetDictSize = maxDictSize; size_t const samplesBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples); size_t dictSize = 0; U32 const notificationLevel = params.zParams.notificationLevel; /* checks */ if (!dictList) return ERROR(memory_allocation); if (maxDictSize < ZDICT_DICTSIZE_MIN) { free(dictList); return ERROR(dstSize_tooSmall); } /* requested dictionary size is too small */ if (samplesBuffSize < ZDICT_MIN_SAMPLES_SIZE) { free(dictList); return ERROR(dictionaryCreation_failed); } /* not enough source to create dictionary */ /* init */ ZDICT_initDictItem(dictList); /* build dictionary */ ZDICT_trainBuffer_legacy(dictList, dictListSize, samplesBuffer, samplesBuffSize, samplesSizes, nbSamples, minRep, notificationLevel); /* display best matches */ if (params.zParams.notificationLevel>= 3) { U32 const nb = MIN(25, dictList[0].pos); U32 const dictContentSize = ZDICT_dictSize(dictList); U32 u; DISPLAYLEVEL(3, "\n %u segments found, of total size %u \n", dictList[0].pos-1, dictContentSize); DISPLAYLEVEL(3, "list %u best segments \n", nb-1); for (u=1; u samplesBuffSize) || ((pos + length) > samplesBuffSize)) return ERROR(GENERIC); /* should never happen */ DISPLAYLEVEL(3, "%3u:%3u bytes at pos %8u, savings %7u bytes |", u, length, pos, dictList[u].savings); ZDICT_printHex((const char*)samplesBuffer+pos, printedLength); DISPLAYLEVEL(3, "| \n"); } } /* create dictionary */ { U32 dictContentSize = ZDICT_dictSize(dictList); if (dictContentSize < ZDICT_CONTENTSIZE_MIN) { free(dictList); return ERROR(dictionaryCreation_failed); } /* dictionary content too small */ if (dictContentSize < targetDictSize/4) { DISPLAYLEVEL(2, "! warning : selected content significantly smaller than requested (%u < %u) \n", dictContentSize, (U32)maxDictSize); if (samplesBuffSize < 10 * targetDictSize) DISPLAYLEVEL(2, "! consider increasing the number of samples (total size : %u MB)\n", (U32)(samplesBuffSize>>20)); if (minRep > MINRATIO) { DISPLAYLEVEL(2, "! consider increasing selectivity to produce larger dictionary (-s%u) \n", selectivity+1); DISPLAYLEVEL(2, "! note : larger dictionaries are not necessarily better, test its efficiency on samples \n"); } } if ((dictContentSize > targetDictSize*3) && (nbSamples > 2*MINRATIO) && (selectivity>1)) { U32 proposedSelectivity = selectivity-1; while ((nbSamples >> proposedSelectivity) <= MINRATIO) { proposedSelectivity--; } DISPLAYLEVEL(2, "! note : calculated dictionary significantly larger than requested (%u > %u) \n", dictContentSize, (U32)maxDictSize); DISPLAYLEVEL(2, "! consider increasing dictionary size, or produce denser dictionary (-s%u) \n", proposedSelectivity); DISPLAYLEVEL(2, "! always test dictionary efficiency on real samples \n"); } /* limit dictionary size */ { U32 const max = dictList->pos; /* convention : nb of useful elts within dictList */ U32 currentSize = 0; U32 n; for (n=1; n targetDictSize) { currentSize -= dictList[n].length; break; } } dictList->pos = n; dictContentSize = currentSize; } /* build dict content */ { U32 u; BYTE* ptr = (BYTE*)dictBuffer + maxDictSize; for (u=1; upos; u++) { U32 l = dictList[u].length; ptr -= l; if (ptr<(BYTE*)dictBuffer) { free(dictList); return ERROR(GENERIC); } /* should not happen */ memcpy(ptr, (const char*)samplesBuffer+dictList[u].pos, l); } } dictSize = ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, maxDictSize, samplesBuffer, samplesSizes, nbSamples, params.zParams); } /* clean up */ free(dictList); return dictSize; } /* ZDICT_trainFromBuffer_legacy() : * issue : samplesBuffer need to be followed by a noisy guard band. * work around : duplicate the buffer, and add the noise */ size_t ZDICT_trainFromBuffer_legacy(void* dictBuffer, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, ZDICT_legacy_params_t params) { size_t result; void* newBuff; size_t const sBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples); if (sBuffSize < ZDICT_MIN_SAMPLES_SIZE) return 0; /* not enough content => no dictionary */ newBuff = malloc(sBuffSize + NOISELENGTH); if (!newBuff) return ERROR(memory_allocation); memcpy(newBuff, samplesBuffer, sBuffSize); ZDICT_fillNoise((char*)newBuff + sBuffSize, NOISELENGTH); /* guard band, for end of buffer condition */ result = ZDICT_trainFromBuffer_unsafe_legacy(dictBuffer, dictBufferCapacity, newBuff, samplesSizes, nbSamples, params); free(newBuff); return result; } size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples) { ZDICT_cover_params_t params; DEBUGLOG(3, "ZDICT_trainFromBuffer"); memset(¶ms, 0, sizeof(params)); params.d = 8; params.steps = 4; /* Default to level 6 since no compression level information is available */ params.zParams.compressionLevel = 6; #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=1) params.zParams.notificationLevel = ZSTD_DEBUG; #endif return ZDICT_optimizeTrainFromBuffer_cover(dictBuffer, dictBufferCapacity, samplesBuffer, samplesSizes, nbSamples, ¶ms); } size_t ZDICT_addEntropyTablesFromBuffer(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples) { ZDICT_params_t params; memset(¶ms, 0, sizeof(params)); return ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, dictBufferCapacity, samplesBuffer, samplesSizes, nbSamples, params); } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zdict.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef DICTBUILDER_H_001 #define DICTBUILDER_H_001 #if defined (__cplusplus) extern "C" { #endif /*====== Dependencies ======*/ #include /* size_t */ /* ===== ZDICTLIB_API : control library symbols visibility ===== */ #ifndef ZDICTLIB_VISIBILITY # if defined(__GNUC__) && (__GNUC__ >= 4) # define ZDICTLIB_VISIBILITY __attribute__ ((visibility ("default"))) # else # define ZDICTLIB_VISIBILITY # endif #endif #if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1) # define ZDICTLIB_API __declspec(dllexport) ZDICTLIB_VISIBILITY #elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1) # define ZDICTLIB_API __declspec(dllimport) ZDICTLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/ #else # define ZDICTLIB_API ZDICTLIB_VISIBILITY #endif /*! ZDICT_trainFromBuffer(): * Train a dictionary from an array of samples. * Redirect towards ZDICT_optimizeTrainFromBuffer_cover() single-threaded, with d=8 and steps=4. * Samples must be stored concatenated in a single flat buffer `samplesBuffer`, * supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order. * The resulting dictionary will be saved into `dictBuffer`. * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) * or an error code, which can be tested with ZDICT_isError(). * Note: ZDICT_trainFromBuffer() requires about 9 bytes of memory for each input byte. * Tips: In general, a reasonable dictionary has a size of ~ 100 KB. * It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`. * In general, it's recommended to provide a few thousands samples, though this can vary a lot. * It's recommended that total size of all samples be about ~x100 times the target size of dictionary. */ ZDICTLIB_API size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples); /*====== Helper functions ======*/ ZDICTLIB_API unsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize); /**< extracts dictID; @return zero if error (not a valid dictionary) */ ZDICTLIB_API unsigned ZDICT_isError(size_t errorCode); ZDICTLIB_API const char* ZDICT_getErrorName(size_t errorCode); #ifdef ZDICT_STATIC_LINKING_ONLY /* ==================================================================================== * The definitions in this section are considered experimental. * They should never be used with a dynamic library, as they may change in the future. * They are provided for advanced usages. * Use them only in association with static linking. * ==================================================================================== */ typedef struct { int compressionLevel; /* optimize for a specific zstd compression level; 0 means default */ unsigned notificationLevel; /* Write log to stderr; 0 = none (default); 1 = errors; 2 = progression; 3 = details; 4 = debug; */ unsigned dictID; /* force dictID value; 0 means auto mode (32-bits random value) */ } ZDICT_params_t; /*! ZDICT_cover_params_t: * k and d are the only required parameters. * For others, value 0 means default. */ typedef struct { unsigned k; /* Segment size : constraint: 0 < k : Reasonable range [16, 2048+] */ unsigned d; /* dmer size : constraint: 0 < d <= k : Reasonable range [6, 16] */ unsigned steps; /* Number of steps : Only used for optimization : 0 means default (32) : Higher means more parameters checked */ unsigned nbThreads; /* Number of threads : constraint: 0 < nbThreads : 1 means single-threaded : Only used for optimization : Ignored if ZSTD_MULTITHREAD is not defined */ ZDICT_params_t zParams; } ZDICT_cover_params_t; /*! ZDICT_trainFromBuffer_cover(): * Train a dictionary from an array of samples using the COVER algorithm. * Samples must be stored concatenated in a single flat buffer `samplesBuffer`, * supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order. * The resulting dictionary will be saved into `dictBuffer`. * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) * or an error code, which can be tested with ZDICT_isError(). * Note: ZDICT_trainFromBuffer_cover() requires about 9 bytes of memory for each input byte. * Tips: In general, a reasonable dictionary has a size of ~ 100 KB. * It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`. * In general, it's recommended to provide a few thousands samples, though this can vary a lot. * It's recommended that total size of all samples be about ~x100 times the target size of dictionary. */ ZDICTLIB_API size_t ZDICT_trainFromBuffer_cover( void *dictBuffer, size_t dictBufferCapacity, const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples, ZDICT_cover_params_t parameters); /*! ZDICT_optimizeTrainFromBuffer_cover(): * The same requirements as above hold for all the parameters except `parameters`. * This function tries many parameter combinations and picks the best parameters. * `*parameters` is filled with the best parameters found, * dictionary constructed with those parameters is stored in `dictBuffer`. * * All of the parameters d, k, steps are optional. * If d is non-zero then we don't check multiple values of d, otherwise we check d = {6, 8, 10, 12, 14, 16}. * if steps is zero it defaults to its default value. * If k is non-zero then we don't check multiple values of k, otherwise we check steps values in [16, 2048]. * * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) * or an error code, which can be tested with ZDICT_isError(). * On success `*parameters` contains the parameters selected. * Note: ZDICT_optimizeTrainFromBuffer_cover() requires about 8 bytes of memory for each input byte and additionally another 5 bytes of memory for each byte of memory for each thread. */ ZDICTLIB_API size_t ZDICT_optimizeTrainFromBuffer_cover( void* dictBuffer, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, ZDICT_cover_params_t* parameters); /*! ZDICT_finalizeDictionary(): * Given a custom content as a basis for dictionary, and a set of samples, * finalize dictionary by adding headers and statistics. * * Samples must be stored concatenated in a flat buffer `samplesBuffer`, * supplied with an array of sizes `samplesSizes`, providing the size of each sample in order. * * dictContentSize must be >= ZDICT_CONTENTSIZE_MIN bytes. * maxDictSize must be >= dictContentSize, and must be >= ZDICT_DICTSIZE_MIN bytes. * * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`), * or an error code, which can be tested by ZDICT_isError(). * Note: ZDICT_finalizeDictionary() will push notifications into stderr if instructed to, using notificationLevel>0. * Note 2: dictBuffer and dictContent can overlap */ #define ZDICT_CONTENTSIZE_MIN 128 #define ZDICT_DICTSIZE_MIN 256 ZDICTLIB_API size_t ZDICT_finalizeDictionary(void* dictBuffer, size_t dictBufferCapacity, const void* dictContent, size_t dictContentSize, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, ZDICT_params_t parameters); typedef struct { unsigned selectivityLevel; /* 0 means default; larger => select more => larger dictionary */ ZDICT_params_t zParams; } ZDICT_legacy_params_t; /*! ZDICT_trainFromBuffer_legacy(): * Train a dictionary from an array of samples. * Samples must be stored concatenated in a single flat buffer `samplesBuffer`, * supplied with an array of sizes `samplesSizes`, providing the size of each sample, in order. * The resulting dictionary will be saved into `dictBuffer`. * `parameters` is optional and can be provided with values set to 0 to mean "default". * @return: size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) * or an error code, which can be tested with ZDICT_isError(). * Tips: In general, a reasonable dictionary has a size of ~ 100 KB. * It's possible to select smaller or larger size, just by specifying `dictBufferCapacity`. * In general, it's recommended to provide a few thousands samples, though this can vary a lot. * It's recommended that total size of all samples be about ~x100 times the target size of dictionary. * Note: ZDICT_trainFromBuffer_legacy() will send notifications into stderr if instructed to, using notificationLevel>0. */ ZDICTLIB_API size_t ZDICT_trainFromBuffer_legacy( void *dictBuffer, size_t dictBufferCapacity, const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples, ZDICT_legacy_params_t parameters); /* Deprecation warnings */ /* It is generally possible to disable deprecation warnings from compiler, for example with -Wno-deprecated-declarations for gcc or _CRT_SECURE_NO_WARNINGS in Visual. Otherwise, it's also possible to manually define ZDICT_DISABLE_DEPRECATE_WARNINGS */ #ifdef ZDICT_DISABLE_DEPRECATE_WARNINGS # define ZDICT_DEPRECATED(message) ZDICTLIB_API /* disable deprecation warnings */ #else # define ZDICT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) # if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */ # define ZDICT_DEPRECATED(message) [[deprecated(message)]] ZDICTLIB_API # elif (ZDICT_GCC_VERSION >= 405) || defined(__clang__) # define ZDICT_DEPRECATED(message) ZDICTLIB_API __attribute__((deprecated(message))) # elif (ZDICT_GCC_VERSION >= 301) # define ZDICT_DEPRECATED(message) ZDICTLIB_API __attribute__((deprecated)) # elif defined(_MSC_VER) # define ZDICT_DEPRECATED(message) ZDICTLIB_API __declspec(deprecated(message)) # else # pragma message("WARNING: You need to implement ZDICT_DEPRECATED for this compiler") # define ZDICT_DEPRECATED(message) ZDICTLIB_API # endif #endif /* ZDICT_DISABLE_DEPRECATE_WARNINGS */ ZDICT_DEPRECATED("use ZDICT_finalizeDictionary() instead") size_t ZDICT_addEntropyTablesFromBuffer(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity, const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples); #endif /* ZDICT_STATIC_LINKING_ONLY */ #if defined (__cplusplus) } #endif #endif /* DICTBUILDER_H_001 */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd.go ================================================ package zstd /* #define ZSTD_STATIC_LINKING_ONLY #include "zstd.h" #include "stdint.h" // for uintptr_t // The following *_wrapper function are used for removing superflouos // memory allocations when calling the wrapped functions from Go code. // See https://github.com/golang/go/issues/24450 for details. static size_t ZSTD_compress_wrapper(uintptr_t dst, size_t maxDstSize, const uintptr_t src, size_t srcSize, int compressionLevel) { return ZSTD_compress((void*)dst, maxDstSize, (const void*)src, srcSize, compressionLevel); } static size_t ZSTD_decompress_wrapper(uintptr_t dst, size_t maxDstSize, uintptr_t src, size_t srcSize) { return ZSTD_decompress((void*)dst, maxDstSize, (const void *)src, srcSize); } */ import "C" import ( "bytes" "errors" "io/ioutil" "unsafe" ) // Defines best and standard values for zstd cli const ( BestSpeed = 1 BestCompression = 20 DefaultCompression = 5 ) var ( // ErrEmptySlice is returned when there is nothing to compress ErrEmptySlice = errors.New("Bytes slice is empty") ) // CompressBound returns the worst case size needed for a destination buffer, // which can be used to preallocate a destination buffer or select a previously // allocated buffer from a pool. // See zstd.h to mirror implementation of ZSTD_COMPRESSBOUND func CompressBound(srcSize int) int { lowLimit := 128 << 10 // 128 kB var margin int if srcSize < lowLimit { margin = (lowLimit - srcSize) >> 11 } return srcSize + (srcSize >> 8) + margin } // cCompressBound is a cgo call to check the go implementation above against the c code. func cCompressBound(srcSize int) int { return int(C.ZSTD_compressBound(C.size_t(srcSize))) } // Compress src into dst. If you have a buffer to use, you can pass it to // prevent allocation. If it is too small, or if nil is passed, a new buffer // will be allocated and returned. func Compress(dst, src []byte) ([]byte, error) { return CompressLevel(dst, src, DefaultCompression) } // CompressLevel is the same as Compress but you can pass a compression level func CompressLevel(dst, src []byte, level int) ([]byte, error) { bound := CompressBound(len(src)) if cap(dst) >= bound { dst = dst[0:bound] // Reuse dst buffer } else { dst = make([]byte, bound) } srcPtr := C.uintptr_t(uintptr(0)) // Do not point anywhere, if src is empty if len(src) > 0 { srcPtr = C.uintptr_t(uintptr(unsafe.Pointer(&src[0]))) } cWritten := C.ZSTD_compress_wrapper( C.uintptr_t(uintptr(unsafe.Pointer(&dst[0]))), C.size_t(len(dst)), srcPtr, C.size_t(len(src)), C.int(level)) written := int(cWritten) // Check if the return is an Error code if err := getError(written); err != nil { return nil, err } return dst[:written], nil } // Decompress src into dst. If you have a buffer to use, you can pass it to // prevent allocation. If it is too small, or if nil is passed, a new buffer // will be allocated and returned. func Decompress(dst, src []byte) ([]byte, error) { if len(src) == 0 { return []byte{}, ErrEmptySlice } decompress := func(dst, src []byte) ([]byte, error) { cWritten := C.ZSTD_decompress_wrapper( C.uintptr_t(uintptr(unsafe.Pointer(&dst[0]))), C.size_t(len(dst)), C.uintptr_t(uintptr(unsafe.Pointer(&src[0]))), C.size_t(len(src))) written := int(cWritten) // Check error if err := getError(written); err != nil { return nil, err } return dst[:written], nil } if dst == nil { // Attempt to use zStd to determine decompressed size (may result in error or 0) size := int(C.size_t(C.ZSTD_getDecompressedSize(unsafe.Pointer(&src[0]), C.size_t(len(src))))) if err := getError(size); err != nil { return nil, err } if size > 0 { dst = make([]byte, size) } else { dst = make([]byte, len(src)*3) // starting guess } } for i := 0; i < 3; i++ { // 3 tries to allocate a bigger buffer result, err := decompress(dst, src) if !IsDstSizeTooSmallError(err) { return result, err } dst = make([]byte, len(dst)*2) // Grow buffer by 2 } // We failed getting a dst buffer of correct size, use stream API r := NewReader(bytes.NewReader(src)) defer r.Close() return ioutil.ReadAll(r) } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #if defined (__cplusplus) extern "C" { #endif #ifndef ZSTD_H_235446 #define ZSTD_H_235446 /* ====== Dependency ======*/ #include /* size_t */ /* ===== ZSTDLIB_API : control library symbols visibility ===== */ #ifndef ZSTDLIB_VISIBILITY # if defined(__GNUC__) && (__GNUC__ >= 4) # define ZSTDLIB_VISIBILITY __attribute__ ((visibility ("default"))) # else # define ZSTDLIB_VISIBILITY # endif #endif #if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1) # define ZSTDLIB_API __declspec(dllexport) ZSTDLIB_VISIBILITY #elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1) # define ZSTDLIB_API __declspec(dllimport) ZSTDLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/ #else # define ZSTDLIB_API ZSTDLIB_VISIBILITY #endif /******************************************************************************************************* Introduction zstd, short for Zstandard, is a fast lossless compression algorithm, targeting real-time compression scenarios at zlib-level and better compression ratios. The zstd compression library provides in-memory compression and decompression functions. The library supports compression levels from 1 up to ZSTD_maxCLevel() which is currently 22. Levels >= 20, labeled `--ultra`, should be used with caution, as they require more memory. Compression can be done in: - a single step (described as Simple API) - a single step, reusing a context (described as Explicit context) - unbounded multiple steps (described as Streaming compression) The compression ratio achievable on small data can be highly improved using a dictionary in: - a single step (described as Simple dictionary API) - a single step, reusing a dictionary (described as Bulk-processing dictionary API) Advanced experimental functions can be accessed using #define ZSTD_STATIC_LINKING_ONLY before including zstd.h. Advanced experimental APIs shall never be used with a dynamic library. They are not "stable", their definition may change in the future. Only static linking is allowed. *********************************************************************************************************/ /*------ Version ------*/ #define ZSTD_VERSION_MAJOR 1 #define ZSTD_VERSION_MINOR 3 #define ZSTD_VERSION_RELEASE 4 #define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE) ZSTDLIB_API unsigned ZSTD_versionNumber(void); /**< useful to check dll version */ #define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE #define ZSTD_QUOTE(str) #str #define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str) #define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION) ZSTDLIB_API const char* ZSTD_versionString(void); /* added in v1.3.0 */ /*************************************** * Simple API ***************************************/ /*! ZSTD_compress() : * Compresses `src` content as a single zstd compressed frame into already allocated `dst`. * Hint : compression runs faster if `dstCapacity` >= `ZSTD_compressBound(srcSize)`. * @return : compressed size written into `dst` (<= `dstCapacity), * or an error code if it fails (which can be tested using ZSTD_isError()). */ ZSTDLIB_API size_t ZSTD_compress( void* dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel); /*! ZSTD_decompress() : * `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames. * `dstCapacity` is an upper bound of originalSize to regenerate. * If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data. * @return : the number of bytes decompressed into `dst` (<= `dstCapacity`), * or an errorCode if it fails (which can be tested using ZSTD_isError()). */ ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity, const void* src, size_t compressedSize); /*! ZSTD_getFrameContentSize() : added in v1.3.0 * `src` should point to the start of a ZSTD encoded frame. * `srcSize` must be at least as large as the frame header. * hint : any size >= `ZSTD_frameHeaderSize_max` is large enough. * @return : - decompressed size of the frame in `src`, if known * - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined * - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) * note 1 : a 0 return value means the frame is valid but "empty". * note 2 : decompressed size is an optional field, it may not be present, typically in streaming mode. * When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size. * In which case, it's necessary to use streaming mode to decompress data. * Optionally, application can rely on some implicit limit, * as ZSTD_decompress() only needs an upper bound of decompressed size. * (For example, data could be necessarily cut into blocks <= 16 KB). * note 3 : decompressed size is always present when compression is done with ZSTD_compress() * note 4 : decompressed size can be very large (64-bits value), * potentially larger than what local system can handle as a single memory segment. * In which case, it's necessary to use streaming mode to decompress data. * note 5 : If source is untrusted, decompressed size could be wrong or intentionally modified. * Always ensure return value fits within application's authorized limits. * Each application can set its own limits. * note 6 : This function replaces ZSTD_getDecompressedSize() */ #define ZSTD_CONTENTSIZE_UNKNOWN (0ULL - 1) #define ZSTD_CONTENTSIZE_ERROR (0ULL - 2) ZSTDLIB_API unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize); /*! ZSTD_getDecompressedSize() : * NOTE: This function is now obsolete, in favor of ZSTD_getFrameContentSize(). * Both functions work the same way, but ZSTD_getDecompressedSize() blends * "empty", "unknown" and "error" results to the same return value (0), * while ZSTD_getFrameContentSize() gives them separate return values. * `src` is the start of a zstd compressed frame. * @return : content size to be decompressed, as a 64-bits value _if known and not empty_, 0 otherwise. */ ZSTDLIB_API unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize); /*====== Helper functions ======*/ #define ZSTD_COMPRESSBOUND(srcSize) ((srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) /* margin, from 64 to 0 */ : 0)) /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */ ZSTDLIB_API size_t ZSTD_compressBound(size_t srcSize); /*!< maximum compressed size in worst case single-pass scenario */ ZSTDLIB_API unsigned ZSTD_isError(size_t code); /*!< tells if a `size_t` function result is an error code */ ZSTDLIB_API const char* ZSTD_getErrorName(size_t code); /*!< provides readable string from an error code */ ZSTDLIB_API int ZSTD_maxCLevel(void); /*!< maximum compression level available */ /*************************************** * Explicit context ***************************************/ /*= Compression context * When compressing many times, * it is recommended to allocate a context just once, and re-use it for each successive compression operation. * This will make workload friendlier for system's memory. * Use one context per thread for parallel execution in multi-threaded environments. */ typedef struct ZSTD_CCtx_s ZSTD_CCtx; ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void); ZSTDLIB_API size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx); /*! ZSTD_compressCCtx() : * Same as ZSTD_compress(), requires an allocated ZSTD_CCtx (see ZSTD_createCCtx()). */ ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel); /*= Decompression context * When decompressing many times, * it is recommended to allocate a context only once, * and re-use it for each successive compression operation. * This will make workload friendlier for system's memory. * Use one context per thread for parallel execution. */ typedef struct ZSTD_DCtx_s ZSTD_DCtx; ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void); ZSTDLIB_API size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx); /*! ZSTD_decompressDCtx() : * Same as ZSTD_decompress(), requires an allocated ZSTD_DCtx (see ZSTD_createDCtx()) */ ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); /************************** * Simple dictionary API ***************************/ /*! ZSTD_compress_usingDict() : * Compression using a predefined Dictionary (see dictBuilder/zdict.h). * Note : This function loads the dictionary, resulting in significant startup delay. * Note : When `dict == NULL || dictSize < 8` no dictionary is used. */ ZSTDLIB_API size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict,size_t dictSize, int compressionLevel); /*! ZSTD_decompress_usingDict() : * Decompression using a predefined Dictionary (see dictBuilder/zdict.h). * Dictionary must be identical to the one used during compression. * Note : This function loads the dictionary, resulting in significant startup delay. * Note : When `dict == NULL || dictSize < 8` no dictionary is used. */ ZSTDLIB_API size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict,size_t dictSize); /********************************** * Bulk processing dictionary API *********************************/ typedef struct ZSTD_CDict_s ZSTD_CDict; /*! ZSTD_createCDict() : * When compressing multiple messages / blocks with the same dictionary, it's recommended to load it just once. * ZSTD_createCDict() will create a digested dictionary, ready to start future compression operations without startup delay. * ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only. * `dictBuffer` can be released after ZSTD_CDict creation, since its content is copied within CDict */ ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict(const void* dictBuffer, size_t dictSize, int compressionLevel); /*! ZSTD_freeCDict() : * Function frees memory allocated by ZSTD_createCDict(). */ ZSTDLIB_API size_t ZSTD_freeCDict(ZSTD_CDict* CDict); /*! ZSTD_compress_usingCDict() : * Compression using a digested Dictionary. * Faster startup than ZSTD_compress_usingDict(), recommended when same dictionary is used multiple times. * Note that compression level is decided during dictionary creation. * Frame parameters are hardcoded (dictID=yes, contentSize=yes, checksum=no) */ ZSTDLIB_API size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const ZSTD_CDict* cdict); typedef struct ZSTD_DDict_s ZSTD_DDict; /*! ZSTD_createDDict() : * Create a digested dictionary, ready to start decompression operation without startup delay. * dictBuffer can be released after DDict creation, as its content is copied inside DDict */ ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict(const void* dictBuffer, size_t dictSize); /*! ZSTD_freeDDict() : * Function frees memory allocated with ZSTD_createDDict() */ ZSTDLIB_API size_t ZSTD_freeDDict(ZSTD_DDict* ddict); /*! ZSTD_decompress_usingDDict() : * Decompression using a digested Dictionary. * Faster startup than ZSTD_decompress_usingDict(), recommended when same dictionary is used multiple times. */ ZSTDLIB_API size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const ZSTD_DDict* ddict); /**************************** * Streaming ****************************/ typedef struct ZSTD_inBuffer_s { const void* src; /**< start of input buffer */ size_t size; /**< size of input buffer */ size_t pos; /**< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size */ } ZSTD_inBuffer; typedef struct ZSTD_outBuffer_s { void* dst; /**< start of output buffer */ size_t size; /**< size of output buffer */ size_t pos; /**< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size */ } ZSTD_outBuffer; /*-*********************************************************************** * Streaming compression - HowTo * * A ZSTD_CStream object is required to track streaming operation. * Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources. * ZSTD_CStream objects can be reused multiple times on consecutive compression operations. * It is recommended to re-use ZSTD_CStream in situations where many streaming operations will be achieved consecutively, * since it will play nicer with system's memory, by re-using already allocated memory. * Use one separate ZSTD_CStream per thread for parallel execution. * * Start a new compression by initializing ZSTD_CStream. * Use ZSTD_initCStream() to start a new compression operation. * Use ZSTD_initCStream_usingDict() or ZSTD_initCStream_usingCDict() for a compression which requires a dictionary (experimental section) * * Use ZSTD_compressStream() repetitively to consume input stream. * The function will automatically update both `pos` fields. * Note that it may not consume the entire input, in which case `pos < size`, * and it's up to the caller to present again remaining data. * @return : a size hint, preferred nb of bytes to use as input for next function call * or an error code, which can be tested using ZSTD_isError(). * Note 1 : it's just a hint, to help latency a little, any other value will work fine. * Note 2 : size hint is guaranteed to be <= ZSTD_CStreamInSize() * * At any moment, it's possible to flush whatever data remains within internal buffer, using ZSTD_flushStream(). * `output->pos` will be updated. * Note that some content might still be left within internal buffer if `output->size` is too small. * @return : nb of bytes still present within internal buffer (0 if it's empty) * or an error code, which can be tested using ZSTD_isError(). * * ZSTD_endStream() instructs to finish a frame. * It will perform a flush and write frame epilogue. * The epilogue is required for decoders to consider a frame completed. * ZSTD_endStream() may not be able to flush full data if `output->size` is too small. * In which case, call again ZSTD_endStream() to complete the flush. * @return : 0 if frame fully completed and fully flushed, or >0 if some data is still present within internal buffer (value is minimum size estimation for remaining data to flush, but it could be more) * or an error code, which can be tested using ZSTD_isError(). * * *******************************************************************/ typedef ZSTD_CCtx ZSTD_CStream; /**< CCtx and CStream are now effectively same object (>= v1.3.0) */ /* Continue to distinguish them for compatibility with versions <= v1.2.0 */ /*===== ZSTD_CStream management functions =====*/ ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream(void); ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs); /*===== Streaming compression functions =====*/ ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel); ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input); ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output); ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output); ZSTDLIB_API size_t ZSTD_CStreamInSize(void); /**< recommended size for input buffer */ ZSTDLIB_API size_t ZSTD_CStreamOutSize(void); /**< recommended size for output buffer. Guarantee to successfully flush at least one complete compressed block in all circumstances. */ /*-*************************************************************************** * Streaming decompression - HowTo * * A ZSTD_DStream object is required to track streaming operations. * Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources. * ZSTD_DStream objects can be re-used multiple times. * * Use ZSTD_initDStream() to start a new decompression operation, * or ZSTD_initDStream_usingDict() if decompression requires a dictionary. * @return : recommended first input size * * Use ZSTD_decompressStream() repetitively to consume your input. * The function will update both `pos` fields. * If `input.pos < input.size`, some input has not been consumed. * It's up to the caller to present again remaining data. * If `output.pos < output.size`, decoder has flushed everything it could. * @return : 0 when a frame is completely decoded and fully flushed, * an error code, which can be tested using ZSTD_isError(), * any other value > 0, which means there is still some decoding to do to complete current frame. * The return value is a suggested next input size (a hint to improve latency) that will never load more than the current frame. * *******************************************************************************/ typedef ZSTD_DCtx ZSTD_DStream; /**< DCtx and DStream are now effectively same object (>= v1.3.0) */ /* For compatibility with versions <= v1.2.0, continue to consider them separated. */ /*===== ZSTD_DStream management functions =====*/ ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void); ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds); /*===== Streaming decompression functions =====*/ ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds); ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input); ZSTDLIB_API size_t ZSTD_DStreamInSize(void); /*!< recommended size for input buffer */ ZSTDLIB_API size_t ZSTD_DStreamOutSize(void); /*!< recommended size for output buffer. Guarantee to successfully flush at least one complete block in all circumstances. */ #endif /* ZSTD_H_235446 */ /**************************************************************************************** * START OF ADVANCED AND EXPERIMENTAL FUNCTIONS * The definitions in this section are considered experimental. * They should never be used with a dynamic library, as prototypes may change in the future. * They are provided for advanced scenarios. * Use them only in association with static linking. * ***************************************************************************************/ #if defined(ZSTD_STATIC_LINKING_ONLY) && !defined(ZSTD_H_ZSTD_STATIC_LINKING_ONLY) #define ZSTD_H_ZSTD_STATIC_LINKING_ONLY /* --- Constants ---*/ #define ZSTD_MAGICNUMBER 0xFD2FB528 /* >= v0.8.0 */ #define ZSTD_MAGIC_SKIPPABLE_START 0x184D2A50U #define ZSTD_MAGIC_DICTIONARY 0xEC30A437 /* >= v0.7.0 */ #define ZSTD_WINDOWLOG_MAX_32 30 #define ZSTD_WINDOWLOG_MAX_64 31 #define ZSTD_WINDOWLOG_MAX ((unsigned)(sizeof(size_t) == 4 ? ZSTD_WINDOWLOG_MAX_32 : ZSTD_WINDOWLOG_MAX_64)) #define ZSTD_WINDOWLOG_MIN 10 #define ZSTD_HASHLOG_MAX ((ZSTD_WINDOWLOG_MAX < 30) ? ZSTD_WINDOWLOG_MAX : 30) #define ZSTD_HASHLOG_MIN 6 #define ZSTD_CHAINLOG_MAX_32 29 #define ZSTD_CHAINLOG_MAX_64 30 #define ZSTD_CHAINLOG_MAX ((unsigned)(sizeof(size_t) == 4 ? ZSTD_CHAINLOG_MAX_32 : ZSTD_CHAINLOG_MAX_64)) #define ZSTD_CHAINLOG_MIN ZSTD_HASHLOG_MIN #define ZSTD_HASHLOG3_MAX 17 #define ZSTD_SEARCHLOG_MAX (ZSTD_WINDOWLOG_MAX-1) #define ZSTD_SEARCHLOG_MIN 1 #define ZSTD_SEARCHLENGTH_MAX 7 /* only for ZSTD_fast, other strategies are limited to 6 */ #define ZSTD_SEARCHLENGTH_MIN 3 /* only for ZSTD_btopt, other strategies are limited to 4 */ #define ZSTD_TARGETLENGTH_MIN 1 /* only used by btopt, btultra and btfast */ #define ZSTD_LDM_MINMATCH_MIN 4 #define ZSTD_LDM_MINMATCH_MAX 4096 #define ZSTD_LDM_BUCKETSIZELOG_MAX 8 #define ZSTD_FRAMEHEADERSIZE_PREFIX 5 /* minimum input size to know frame header size */ #define ZSTD_FRAMEHEADERSIZE_MIN 6 #define ZSTD_FRAMEHEADERSIZE_MAX 18 /* for static allocation */ static const size_t ZSTD_frameHeaderSize_prefix = ZSTD_FRAMEHEADERSIZE_PREFIX; static const size_t ZSTD_frameHeaderSize_min = ZSTD_FRAMEHEADERSIZE_MIN; static const size_t ZSTD_frameHeaderSize_max = ZSTD_FRAMEHEADERSIZE_MAX; static const size_t ZSTD_skippableHeaderSize = 8; /* magic number + skippable frame length */ /*--- Advanced types ---*/ typedef enum { ZSTD_fast=1, ZSTD_dfast, ZSTD_greedy, ZSTD_lazy, ZSTD_lazy2, ZSTD_btlazy2, ZSTD_btopt, ZSTD_btultra } ZSTD_strategy; /* from faster to stronger */ typedef struct { unsigned windowLog; /**< largest match distance : larger == more compression, more memory needed during decompression */ unsigned chainLog; /**< fully searched segment : larger == more compression, slower, more memory (useless for fast) */ unsigned hashLog; /**< dispatch table : larger == faster, more memory */ unsigned searchLog; /**< nb of searches : larger == more compression, slower */ unsigned searchLength; /**< match length searched : larger == faster decompression, sometimes less compression */ unsigned targetLength; /**< acceptable match size for optimal parser (only) : larger == more compression, slower */ ZSTD_strategy strategy; } ZSTD_compressionParameters; typedef struct { unsigned contentSizeFlag; /**< 1: content size will be in frame header (when known) */ unsigned checksumFlag; /**< 1: generate a 32-bits checksum at end of frame, for error detection */ unsigned noDictIDFlag; /**< 1: no dictID will be saved into frame header (if dictionary compression) */ } ZSTD_frameParameters; typedef struct { ZSTD_compressionParameters cParams; ZSTD_frameParameters fParams; } ZSTD_parameters; typedef struct ZSTD_CCtx_params_s ZSTD_CCtx_params; typedef enum { ZSTD_dct_auto=0, /* dictionary is "full" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is "rawContent" */ ZSTD_dct_rawContent, /* ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY */ ZSTD_dct_fullDict /* refuses to load a dictionary if it does not respect Zstandard's specification */ } ZSTD_dictContentType_e; typedef enum { ZSTD_dlm_byCopy = 0, /**< Copy dictionary content internally */ ZSTD_dlm_byRef, /**< Reference dictionary content -- the dictionary buffer must outlive its users. */ } ZSTD_dictLoadMethod_e; /*************************************** * Frame size functions ***************************************/ /*! ZSTD_findFrameCompressedSize() : * `src` should point to the start of a ZSTD encoded frame or skippable frame * `srcSize` must be >= first frame size * @return : the compressed size of the first frame starting at `src`, * suitable to pass to `ZSTD_decompress` or similar, * or an error code if input is invalid */ ZSTDLIB_API size_t ZSTD_findFrameCompressedSize(const void* src, size_t srcSize); /*! ZSTD_findDecompressedSize() : * `src` should point the start of a series of ZSTD encoded and/or skippable frames * `srcSize` must be the _exact_ size of this series * (i.e. there should be a frame boundary exactly at `srcSize` bytes after `src`) * @return : - decompressed size of all data in all successive frames * - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN * - if an error occurred: ZSTD_CONTENTSIZE_ERROR * * note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode. * When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size. * In which case, it's necessary to use streaming mode to decompress data. * note 2 : decompressed size is always present when compression is done with ZSTD_compress() * note 3 : decompressed size can be very large (64-bits value), * potentially larger than what local system can handle as a single memory segment. * In which case, it's necessary to use streaming mode to decompress data. * note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified. * Always ensure result fits within application's authorized limits. * Each application can set its own limits. * note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to * read each contained frame header. This is fast as most of the data is skipped, * however it does mean that all frame data must be present and valid. */ ZSTDLIB_API unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize); /*! ZSTD_frameHeaderSize() : * `src` should point to the start of a ZSTD frame * `srcSize` must be >= ZSTD_frameHeaderSize_prefix. * @return : size of the Frame Header */ ZSTDLIB_API size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize); /*************************************** * Memory management ***************************************/ /*! ZSTD_sizeof_*() : * These functions give the current memory usage of selected object. * Object memory usage can evolve when re-used. */ ZSTDLIB_API size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx); ZSTDLIB_API size_t ZSTD_sizeof_DCtx(const ZSTD_DCtx* dctx); ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs); ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds); ZSTDLIB_API size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict); ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict); /*! ZSTD_estimate*() : * These functions make it possible to estimate memory usage * of a future {D,C}Ctx, before its creation. * ZSTD_estimateCCtxSize() will provide a budget large enough for any compression level up to selected one. * It will also consider src size to be arbitrarily "large", which is worst case. * If srcSize is known to always be small, ZSTD_estimateCCtxSize_usingCParams() can provide a tighter estimation. * ZSTD_estimateCCtxSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel. * ZSTD_estimateCCtxSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParam_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_p_nbWorkers is >= 1. * Note : CCtx size estimation is only correct for single-threaded compression. */ ZSTDLIB_API size_t ZSTD_estimateCCtxSize(int compressionLevel); ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams); ZSTDLIB_API size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params); ZSTDLIB_API size_t ZSTD_estimateDCtxSize(void); /*! ZSTD_estimateCStreamSize() : * ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one. * It will also consider src size to be arbitrarily "large", which is worst case. * If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation. * ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel. * ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParam_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_p_nbWorkers is >= 1. * Note : CStream size estimation is only correct for single-threaded compression. * ZSTD_DStream memory budget depends on window Size. * This information can be passed manually, using ZSTD_estimateDStreamSize, * or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame(); * Note : if streaming is init with function ZSTD_init?Stream_usingDict(), * an internal ?Dict will be created, which additional size is not estimated here. * In this case, get total size by adding ZSTD_estimate?DictSize */ ZSTDLIB_API size_t ZSTD_estimateCStreamSize(int compressionLevel); ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams); ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params); ZSTDLIB_API size_t ZSTD_estimateDStreamSize(size_t windowSize); ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize); /*! ZSTD_estimate?DictSize() : * ZSTD_estimateCDictSize() will bet that src size is relatively "small", and content is copied, like ZSTD_createCDict(). * ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced(). * Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller. */ ZSTDLIB_API size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel); ZSTDLIB_API size_t ZSTD_estimateCDictSize_advanced(size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod); ZSTDLIB_API size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod); /*! ZSTD_initStatic*() : * Initialize an object using a pre-allocated fixed-size buffer. * workspace: The memory area to emplace the object into. * Provided pointer *must be 8-bytes aligned*. * Buffer must outlive object. * workspaceSize: Use ZSTD_estimate*Size() to determine * how large workspace must be to support target scenario. * @return : pointer to object (same address as workspace, just different type), * or NULL if error (size too small, incorrect alignment, etc.) * Note : zstd will never resize nor malloc() when using a static buffer. * If the object requires more memory than available, * zstd will just error out (typically ZSTD_error_memory_allocation). * Note 2 : there is no corresponding "free" function. * Since workspace is allocated externally, it must be freed externally too. * Note 3 : cParams : use ZSTD_getCParams() to convert a compression level * into its associated cParams. * Limitation 1 : currently not compatible with internal dictionary creation, triggered by * ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict(). * Limitation 2 : static cctx currently not compatible with multi-threading. * Limitation 3 : static dctx is incompatible with legacy support. */ ZSTDLIB_API ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize); ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize); /**< same as ZSTD_initStaticCCtx() */ ZSTDLIB_API ZSTD_DCtx* ZSTD_initStaticDCtx(void* workspace, size_t workspaceSize); ZSTDLIB_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize); /**< same as ZSTD_initStaticDCtx() */ ZSTDLIB_API const ZSTD_CDict* ZSTD_initStaticCDict( void* workspace, size_t workspaceSize, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_compressionParameters cParams); ZSTDLIB_API const ZSTD_DDict* ZSTD_initStaticDDict( void* workspace, size_t workspaceSize, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType); /*! Custom memory allocation : * These prototypes make it possible to pass your own allocation/free functions. * ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below. * All allocation/free operations will be completed using these custom variants instead of regular ones. */ typedef void* (*ZSTD_allocFunction) (void* opaque, size_t size); typedef void (*ZSTD_freeFunction) (void* opaque, void* address); typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem; static ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL }; /**< this constant defers to stdlib's functions */ ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem); ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem); ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem); ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem); ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_compressionParameters cParams, ZSTD_customMem customMem); ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_customMem customMem); /*************************************** * Advanced compression functions ***************************************/ /*! ZSTD_createCDict_byReference() : * Create a digested dictionary for compression * Dictionary content is simply referenced, and therefore stays in dictBuffer. * It is important that dictBuffer outlives CDict, it must remain read accessible throughout the lifetime of CDict */ ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_byReference(const void* dictBuffer, size_t dictSize, int compressionLevel); /*! ZSTD_getCParams() : * @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize. * `estimatedSrcSize` value is optional, select 0 if not known */ ZSTDLIB_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize); /*! ZSTD_getParams() : * same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`. * All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 */ ZSTDLIB_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize); /*! ZSTD_checkCParams() : * Ensure param values remain within authorized range */ ZSTDLIB_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params); /*! ZSTD_adjustCParams() : * optimize params for a given `srcSize` and `dictSize`. * both values are optional, select `0` if unknown. */ ZSTDLIB_API ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize); /*! ZSTD_compress_advanced() : * Same as ZSTD_compress_usingDict(), with fine-tune control over each compression parameter */ ZSTDLIB_API size_t ZSTD_compress_advanced (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict,size_t dictSize, ZSTD_parameters params); /*! ZSTD_compress_usingCDict_advanced() : * Same as ZSTD_compress_usingCDict(), with fine-tune control over frame parameters */ ZSTDLIB_API size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams); /*--- Advanced decompression functions ---*/ /*! ZSTD_isFrame() : * Tells if the content of `buffer` starts with a valid Frame Identifier. * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0. * Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled. * Note 3 : Skippable Frame Identifiers are considered valid. */ ZSTDLIB_API unsigned ZSTD_isFrame(const void* buffer, size_t size); /*! ZSTD_createDDict_byReference() : * Create a digested dictionary, ready to start decompression operation without startup delay. * Dictionary content is referenced, and therefore stays in dictBuffer. * It is important that dictBuffer outlives DDict, * it must remain read accessible throughout the lifetime of DDict */ ZSTDLIB_API ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize); /*! ZSTD_getDictID_fromDict() : * Provides the dictID stored within dictionary. * if @return == 0, the dictionary is not conformant with Zstandard specification. * It can still be loaded, but as a content-only dictionary. */ ZSTDLIB_API unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize); /*! ZSTD_getDictID_fromDDict() : * Provides the dictID of the dictionary loaded into `ddict`. * If @return == 0, the dictionary is not conformant to Zstandard specification, or empty. * Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */ ZSTDLIB_API unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict); /*! ZSTD_getDictID_fromFrame() : * Provides the dictID required to decompressed the frame stored within `src`. * If @return == 0, the dictID could not be decoded. * This could for one of the following reasons : * - The frame does not require a dictionary to be decoded (most common case). * - The frame was built with dictID intentionally removed. Whatever dictionary is necessary is a hidden information. * Note : this use case also happens when using a non-conformant dictionary. * - `srcSize` is too small, and as a result, the frame header could not be decoded (only possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`). * - This is not a Zstandard frame. * When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code. */ ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize); /******************************************************************** * Advanced streaming functions ********************************************************************/ /*===== Advanced Streaming compression functions =====*/ ZSTDLIB_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize); /**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, "0" also disables frame content size field. It may be enabled in the future. */ ZSTDLIB_API size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel); /**< creates of an internal CDict (incompatible with static CCtx), except if dict == NULL or dictSize < 8, in which case no dict is used. Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.*/ ZSTDLIB_API size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize must be correct. If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */ ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict); /**< note : cdict will just be referenced, and must outlive compression session */ ZSTDLIB_API size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize); /**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters. pledgedSrcSize must be correct. If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. */ /*! ZSTD_resetCStream() : * start a new compression job, using same parameters from previous job. * This is typically useful to skip dictionary loading stage, since it will re-use it in-place.. * Note that zcs must be init at least once before using ZSTD_resetCStream(). * If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN. * If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end. * For the time being, pledgedSrcSize==0 is interpreted as "srcSize unknown" for compatibility with older programs, * but it will change to mean "empty" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead. * @return : 0, or an error code (which can be tested using ZSTD_isError()) */ ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize); typedef struct { unsigned long long ingested; unsigned long long consumed; unsigned long long produced; } ZSTD_frameProgression; /* ZSTD_getFrameProgression(): * tells how much data has been ingested (read from input) * consumed (input actually compressed) and produced (output) for current frame. * Therefore, (ingested - consumed) is amount of input data buffered internally, not yet compressed. * Can report progression inside worker threads (multi-threading and non-blocking mode). */ ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx); /*===== Advanced Streaming decompression functions =====*/ typedef enum { DStream_p_maxWindowSize } ZSTD_DStreamParameter_e; ZSTDLIB_API size_t ZSTD_setDStreamParameter(ZSTD_DStream* zds, ZSTD_DStreamParameter_e paramType, unsigned paramValue); /* obsolete : this API will be removed in a future version */ ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize); /**< note: no dictionary will be used if dict == NULL or dictSize < 8 */ ZSTDLIB_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict); /**< note : ddict is referenced, it must outlive decompression session */ ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds); /**< re-use decompression parameters from previous init; saves dictionary loading */ /********************************************************************* * Buffer-less and synchronous inner streaming functions * * This is an advanced API, giving full control over buffer management, for users which need direct control over memory. * But it's also a complex one, with several restrictions, documented below. * Prefer normal streaming API for an easier experience. ********************************************************************* */ /** Buffer-less streaming compression (synchronous mode) A ZSTD_CCtx object is required to track streaming operations. Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource. ZSTD_CCtx object can be re-used multiple times within successive compression operations. Start by initializing a context. Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression, or ZSTD_compressBegin_advanced(), for finer parameter control. It's also possible to duplicate a reference context which has already been initialized, using ZSTD_copyCCtx() Then, consume your input using ZSTD_compressContinue(). There are some important considerations to keep in mind when using this advanced function : - ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only. - Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks. - Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario. Worst case evaluation is provided by ZSTD_compressBound(). ZSTD_compressContinue() doesn't guarantee recover after a failed compression. - ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog). It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks) - ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps. In which case, it will "discard" the relevant memory section from its history. Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum. It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame. Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders. `ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again. */ /*===== Buffer-less streaming compression functions =====*/ ZSTDLIB_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel); ZSTDLIB_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel); ZSTDLIB_API size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize : If srcSize is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN */ ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /**< note: fails if cdict==NULL */ ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize); /* compression parameters are already set within cdict. pledgedSrcSize must be correct. If srcSize is not known, use macro ZSTD_CONTENTSIZE_UNKNOWN */ ZSTDLIB_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /**< note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN */ ZSTDLIB_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); /*- Buffer-less streaming decompression (synchronous mode) A ZSTD_DCtx object is required to track streaming operations. Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it. A ZSTD_DCtx object can be re-used multiple times. First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader(). Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough. Data fragment must be large enough to ensure successful decoding. `ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough. @result : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled. >0 : `srcSize` is too small, please provide at least @result bytes on next attempt. errorCode, which can be tested using ZSTD_isError(). It fills a ZSTD_frameHeader structure with important information to correctly decode the frame, such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`). Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information. As a consequence, check that values remain within valid application range. For example, do not allocate memory blindly, check that `windowSize` is within expectation. Each application can set its own limits, depending on local restrictions. For extended interoperability, it is recommended to support `windowSize` of at least 8 MB. ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes. ZSTD_decompressContinue() is very sensitive to contiguity, if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place, or that previous contiguous segment is large enough to properly handle maximum back-reference distance. There are multiple ways to guarantee this condition. The most memory efficient way is to use a round buffer of sufficient size. Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(), which can @return an error code if required value is too large for current system (in 32-bits mode). In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one, up to the moment there is not enough room left in the buffer to guarantee decoding another full block, which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`. At which point, decoding can resume from the beginning of the buffer. Note that already decoded data stored in the buffer should be flushed before being overwritten. There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory. Finally, if you control the compression process, you can also ignore all buffer size rules, as long as the encoder and decoder progress in "lock-step", aka use exactly the same buffer sizes, break contiguity at the same place, etc. Once buffers are setup, start decompression, with ZSTD_decompressBegin(). If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict(). Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively. ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue(). ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail. @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity). It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item. It can also be an error code, which can be tested with ZSTD_isError(). A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero. Context can then be reset to start a new decompression. Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType(). This information is not required to properly decode a frame. == Special case : skippable frames == Skippable frames allow integration of user-defined data into a flow of concatenated frames. Skippable frames will be ignored (skipped) by decompressor. The format of skippable frames is as follows : a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits c) Frame Content - any content (User Data) of length equal to Frame Size For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame. For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content. */ /*===== Buffer-less streaming decompression functions =====*/ typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e; typedef struct { unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" */ unsigned long long windowSize; /* can be very large, up to <= frameContentSize */ unsigned blockSizeMax; ZSTD_frameType_e frameType; /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */ unsigned headerSize; unsigned dictID; unsigned checksumFlag; } ZSTD_frameHeader; ZSTDLIB_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize); /**< doesn't consume input */ ZSTDLIB_API size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize); /**< when frame content size is not known, pass in frameContentSize == ZSTD_CONTENTSIZE_UNKNOWN */ ZSTDLIB_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx); ZSTDLIB_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize); ZSTDLIB_API size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict); ZSTDLIB_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx); ZSTDLIB_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); /* misc */ ZSTDLIB_API void ZSTD_copyDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx); typedef enum { ZSTDnit_frameHeader, ZSTDnit_blockHeader, ZSTDnit_block, ZSTDnit_lastBlock, ZSTDnit_checksum, ZSTDnit_skippableFrame } ZSTD_nextInputType_e; ZSTDLIB_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx); /* ============================================ */ /** New advanced API (experimental) */ /* ============================================ */ /* notes on API design : * In this proposal, parameters are pushed one by one into an existing context, * and then applied on all subsequent compression jobs. * When no parameter is ever provided, CCtx is created with compression level ZSTD_CLEVEL_DEFAULT. * * This API is intended to replace all others advanced / experimental API entry points. * But it stands a reasonable chance to become "stable", after a reasonable testing period. */ /* note on naming convention : * Initially, the API favored names like ZSTD_setCCtxParameter() . * In this proposal, convention is changed towards ZSTD_CCtx_setParameter() . * The main driver is that it identifies more clearly the target object type. * It feels clearer when considering multiple targets : * ZSTD_CDict_setParameter() (rather than ZSTD_setCDictParameter()) * ZSTD_CCtxParams_setParameter() (rather than ZSTD_setCCtxParamsParameter() ) * etc... */ /* note on enum design : * All enum will be pinned to explicit values before reaching "stable API" status */ typedef enum { /* Opened question : should we have a format ZSTD_f_auto ? * Today, it would mean exactly the same as ZSTD_f_zstd1. * But, in the future, should several formats become supported, * on the compression side, it would mean "default format". * On the decompression side, it would mean "automatic format detection", * so that ZSTD_f_zstd1 would mean "accept *only* zstd frames". * Since meaning is a little different, another option could be to define different enums for compression and decompression. * This question could be kept for later, when there are actually multiple formats to support, * but there is also the question of pinning enum values, and pinning value `0` is especially important */ ZSTD_f_zstd1 = 0, /* zstd frame format, specified in zstd_compression_format.md (default) */ ZSTD_f_zstd1_magicless, /* Variant of zstd frame format, without initial 4-bytes magic number. * Useful to save 4 bytes per generated frame. * Decoder cannot recognise automatically this format, requiring instructions. */ } ZSTD_format_e; typedef enum { /* compression format */ ZSTD_p_format = 10, /* See ZSTD_format_e enum definition. * Cast selected format as unsigned for ZSTD_CCtx_setParameter() compatibility. */ /* compression parameters */ ZSTD_p_compressionLevel=100, /* Update all compression parameters according to pre-defined cLevel table * Default level is ZSTD_CLEVEL_DEFAULT==3. * Special: value 0 means "do not change cLevel". * Note 1 : it's possible to pass a negative compression level by casting it to unsigned type. * Note 2 : setting a level sets all default values of other compression parameters. * Note 3 : setting compressionLevel automatically updates ZSTD_p_compressLiterals. */ ZSTD_p_windowLog, /* Maximum allowed back-reference distance, expressed as power of 2. * Must be clamped between ZSTD_WINDOWLOG_MIN and ZSTD_WINDOWLOG_MAX. * Special: value 0 means "use default windowLog". * Note: Using a window size greater than ZSTD_MAXWINDOWSIZE_DEFAULT (default: 2^27) * requires explicitly allowing such window size during decompression stage. */ ZSTD_p_hashLog, /* Size of the probe table, as a power of 2. * Resulting table size is (1 << (hashLog+2)). * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX. * Larger tables improve compression ratio of strategies <= dFast, * and improve speed of strategies > dFast. * Special: value 0 means "use default hashLog". */ ZSTD_p_chainLog, /* Size of the full-search table, as a power of 2. * Resulting table size is (1 << (chainLog+2)). * Larger tables result in better and slower compression. * This parameter is useless when using "fast" strategy. * Special: value 0 means "use default chainLog". */ ZSTD_p_searchLog, /* Number of search attempts, as a power of 2. * More attempts result in better and slower compression. * This parameter is useless when using "fast" and "dFast" strategies. * Special: value 0 means "use default searchLog". */ ZSTD_p_minMatch, /* Minimum size of searched matches (note : repCode matches can be smaller). * Larger values make faster compression and decompression, but decrease ratio. * Must be clamped between ZSTD_SEARCHLENGTH_MIN and ZSTD_SEARCHLENGTH_MAX. * Note that currently, for all strategies < btopt, effective minimum is 4. * , for all strategies > fast, effective maximum is 6. * Special: value 0 means "use default minMatchLength". */ ZSTD_p_targetLength, /* Impact of this field depends on strategy. * For strategies btopt & btultra: * Length of Match considered "good enough" to stop search. * Larger values make compression stronger, and slower. * For strategy fast: * Distance between match sampling. * Larger values make compression faster, and weaker. * Special: value 0 means "use default targetLength". */ ZSTD_p_compressionStrategy, /* See ZSTD_strategy enum definition. * Cast selected strategy as unsigned for ZSTD_CCtx_setParameter() compatibility. * The higher the value of selected strategy, the more complex it is, * resulting in stronger and slower compression. * Special: value 0 means "use default strategy". */ ZSTD_p_enableLongDistanceMatching=160, /* Enable long distance matching. * This parameter is designed to improve compression ratio * for large inputs, by finding large matches at long distance. * It increases memory usage and window size. * Note: enabling this parameter increases ZSTD_p_windowLog to 128 MB * except when expressly set to a different value. */ ZSTD_p_ldmHashLog, /* Size of the table for long distance matching, as a power of 2. * Larger values increase memory usage and compression ratio, * but decrease compression speed. * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX * default: windowlog - 7. * Special: value 0 means "automatically determine hashlog". */ ZSTD_p_ldmMinMatch, /* Minimum match size for long distance matcher. * Larger/too small values usually decrease compression ratio. * Must be clamped between ZSTD_LDM_MINMATCH_MIN and ZSTD_LDM_MINMATCH_MAX. * Special: value 0 means "use default value" (default: 64). */ ZSTD_p_ldmBucketSizeLog, /* Log size of each bucket in the LDM hash table for collision resolution. * Larger values improve collision resolution but decrease compression speed. * The maximum value is ZSTD_LDM_BUCKETSIZELOG_MAX . * Special: value 0 means "use default value" (default: 3). */ ZSTD_p_ldmHashEveryLog, /* Frequency of inserting/looking up entries in the LDM hash table. * Must be clamped between 0 and (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN). * Default is MAX(0, (windowLog - ldmHashLog)), optimizing hash table usage. * Larger values improve compression speed. * Deviating far from default value will likely result in a compression ratio decrease. * Special: value 0 means "automatically determine hashEveryLog". */ /* frame parameters */ ZSTD_p_contentSizeFlag=200, /* Content size will be written into frame header _whenever known_ (default:1) * Content size must be known at the beginning of compression, * it is provided using ZSTD_CCtx_setPledgedSrcSize() */ ZSTD_p_checksumFlag, /* A 32-bits checksum of content is written at end of frame (default:0) */ ZSTD_p_dictIDFlag, /* When applicable, dictionary's ID is written into frame header (default:1) */ /* multi-threading parameters */ /* These parameters are only useful if multi-threading is enabled (ZSTD_MULTITHREAD). * They return an error otherwise. */ ZSTD_p_nbWorkers=400, /* Select how many threads will be spawned to compress in parallel. * When nbWorkers >= 1, triggers asynchronous mode : * ZSTD_compress_generic() consumes some input, flush some output if possible, and immediately gives back control to caller, * while compression work is performed in parallel, within worker threads. * (note : a strong exception to this rule is when first invocation sets ZSTD_e_end : it becomes a blocking call). * More workers improve speed, but also increase memory usage. * Default value is `0`, aka "single-threaded mode" : no worker is spawned, compression is performed inside Caller's thread, all invocations are blocking */ ZSTD_p_jobSize, /* Size of a compression job. This value is enforced only in non-blocking mode. * Each compression job is completed in parallel, so this value indirectly controls the nb of active threads. * 0 means default, which is dynamically determined based on compression parameters. * Job size must be a minimum of overlapSize, or 1 MB, whichever is largest. * The minimum size is automatically and transparently enforced */ ZSTD_p_overlapSizeLog, /* Size of previous input reloaded at the beginning of each job. * 0 => no overlap, 6(default) => use 1/8th of windowSize, >=9 => use full windowSize */ /* =================================================================== */ /* experimental parameters - no stability guaranteed */ /* =================================================================== */ ZSTD_p_compressLiterals=1000, /* control huffman compression of literals (enabled) by default. * disabling it improves speed and decreases compression ratio by a large amount. * note : this setting is automatically updated when changing compression level. * positive compression levels set ZSTD_p_compressLiterals to 1. * negative compression levels set ZSTD_p_compressLiterals to 0. */ ZSTD_p_forceMaxWindow=1100, /* Force back-reference distances to remain < windowSize, * even when referencing into Dictionary content (default:0) */ } ZSTD_cParameter; /*! ZSTD_CCtx_setParameter() : * Set one compression parameter, selected by enum ZSTD_cParameter. * Setting a parameter is generally only possible during frame initialization (before starting compression), * except for a few exceptions which can be updated during compression: compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy. * Note : when `value` is an enum, cast it to unsigned for proper type checking. * @result : informational value (typically, value being set clamped correctly), * or an error code (which can be tested with ZSTD_isError()). */ ZSTDLIB_API size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned value); /*! ZSTD_CCtx_setPledgedSrcSize() : * Total input data size to be compressed as a single frame. * This value will be controlled at the end, and result in error if not respected. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Note 1 : 0 means zero, empty. * In order to mean "unknown content size", pass constant ZSTD_CONTENTSIZE_UNKNOWN. * ZSTD_CONTENTSIZE_UNKNOWN is default value for any new compression job. * Note 2 : If all data is provided and consumed in a single round, * this value is overriden by srcSize instead. */ ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize); /*! ZSTD_CCtx_loadDictionary() : * Create an internal CDict from `dict` buffer. * Decompression will have to use same dictionary. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Special: Adding a NULL (or 0-size) dictionary invalidates previous dictionary, * meaning "return to no-dictionary mode". * Note 1 : Dictionary will be used for all future compression jobs. * To return to "no-dictionary" situation, load a NULL dictionary * Note 2 : Loading a dictionary involves building tables, which are dependent on compression parameters. * For this reason, compression parameters cannot be changed anymore after loading a dictionary. * It's also a CPU consuming operation, with non-negligible impact on latency. * Note 3 :`dict` content will be copied internally. * Use ZSTD_CCtx_loadDictionary_byReference() to reference dictionary content instead. * In such a case, dictionary buffer must outlive its users. * Note 4 : Use ZSTD_CCtx_loadDictionary_advanced() * to precisely select how dictionary content must be interpreted. */ ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize); ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference(ZSTD_CCtx* cctx, const void* dict, size_t dictSize); ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType); /*! ZSTD_CCtx_refCDict() : * Reference a prepared dictionary, to be used for all next compression jobs. * Note that compression parameters are enforced from within CDict, * and supercede any compression parameter previously set within CCtx. * The dictionary will remain valid for future compression jobs using same CCtx. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Special : adding a NULL CDict means "return to no-dictionary mode". * Note 1 : Currently, only one dictionary can be managed. * Adding a new dictionary effectively "discards" any previous one. * Note 2 : CDict is just referenced, its lifetime must outlive CCtx. */ ZSTDLIB_API size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /*! ZSTD_CCtx_refPrefix() : * Reference a prefix (single-usage dictionary) for next compression job. * Decompression need same prefix to properly regenerate data. * Prefix is **only used once**. Tables are discarded at end of compression job. * Subsequent compression jobs will be done without prefix (if none is explicitly referenced). * If there is a need to use same prefix multiple times, consider embedding it into a ZSTD_CDict instead. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary * Note 1 : Prefix buffer is referenced. It must outlive compression job. * Note 2 : Referencing a prefix involves building tables, which are dependent on compression parameters. * It's a CPU consuming operation, with non-negligible impact on latency. * Note 3 : By default, the prefix is treated as raw content (ZSTD_dm_rawContent). * Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode. */ ZSTDLIB_API size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize); ZSTDLIB_API size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType); /*! ZSTD_CCtx_reset() : * Return a CCtx to clean state. * Useful after an error, or to interrupt an ongoing compression job and start a new one. * Any internal data not yet flushed is cancelled. * Dictionary (if any) is dropped. * All parameters are back to default values. * It's possible to modify compression parameters after a reset. */ ZSTDLIB_API void ZSTD_CCtx_reset(ZSTD_CCtx* cctx); typedef enum { ZSTD_e_continue=0, /* collect more data, encoder decides when to output compressed result, for optimal conditions */ ZSTD_e_flush, /* flush any data provided so far - frame will continue, future data can still reference previous data for better compression */ ZSTD_e_end /* flush any remaining data and close current frame. Any additional data starts a new frame. */ } ZSTD_EndDirective; /*! ZSTD_compress_generic() : * Behave about the same as ZSTD_compressStream. To note : * - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_setParameter() * - Compression parameters cannot be changed once compression is started. * - outpot->pos must be <= dstCapacity, input->pos must be <= srcSize * - outpot->pos and input->pos will be updated. They are guaranteed to remain below their respective limit. * - In single-thread mode (default), function is blocking : it completed its job before returning to caller. * - In multi-thread mode, function is non-blocking : it just acquires a copy of input, and distribute job to internal worker threads, * and then immediately returns, just indicating that there is some data remaining to be flushed. * The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte. * - Exception : in multi-threading mode, if the first call requests a ZSTD_e_end directive, it is blocking : it will complete compression before giving back control to caller. * - @return provides a minimum amount of data remaining to be flushed from internal buffers * or an error code, which can be tested using ZSTD_isError(). * if @return != 0, flush is not fully completed, there is still some data left within internal buffers. * This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers. * For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed. * - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0), * only ZSTD_e_end or ZSTD_e_flush operations are allowed. * Before starting a new compression job, or changing compression parameters, * it is required to fully flush internal buffers. */ ZSTDLIB_API size_t ZSTD_compress_generic (ZSTD_CCtx* cctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input, ZSTD_EndDirective endOp); /*! ZSTD_compress_generic_simpleArgs() : * Same as ZSTD_compress_generic(), * but using only integral types as arguments. * Argument list is larger than ZSTD_{in,out}Buffer, * but can be helpful for binders from dynamic languages * which have troubles handling structures containing memory pointers. */ ZSTDLIB_API size_t ZSTD_compress_generic_simpleArgs ( ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, size_t* dstPos, const void* src, size_t srcSize, size_t* srcPos, ZSTD_EndDirective endOp); /*! ZSTD_CCtx_params : * Quick howto : * - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure * - ZSTD_CCtxParam_setParameter() : Push parameters one by one into * an existing ZSTD_CCtx_params structure. * This is similar to * ZSTD_CCtx_setParameter(). * - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to * an existing CCtx. * These parameters will be applied to * all subsequent compression jobs. * - ZSTD_compress_generic() : Do compression using the CCtx. * - ZSTD_freeCCtxParams() : Free the memory. * * This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams() * for static allocation for single-threaded compression. */ ZSTDLIB_API ZSTD_CCtx_params* ZSTD_createCCtxParams(void); ZSTDLIB_API size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params); /*! ZSTD_CCtxParams_reset() : * Reset params to default values. */ ZSTDLIB_API size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params); /*! ZSTD_CCtxParams_init() : * Initializes the compression parameters of cctxParams according to * compression level. All other parameters are reset to their default values. */ ZSTDLIB_API size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel); /*! ZSTD_CCtxParams_init_advanced() : * Initializes the compression and frame parameters of cctxParams according to * params. All other parameters are reset to their default values. */ ZSTDLIB_API size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params); /*! ZSTD_CCtxParam_setParameter() : * Similar to ZSTD_CCtx_setParameter. * Set one compression parameter, selected by enum ZSTD_cParameter. * Parameters must be applied to a ZSTD_CCtx using ZSTD_CCtx_setParametersUsingCCtxParams(). * Note : when `value` is an enum, cast it to unsigned for proper type checking. * @result : 0, or an error code (which can be tested with ZSTD_isError()). */ ZSTDLIB_API size_t ZSTD_CCtxParam_setParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, unsigned value); /*! ZSTD_CCtx_setParametersUsingCCtxParams() : * Apply a set of ZSTD_CCtx_params to the compression context. * This can be done even after compression is started, * if nbWorkers==0, this will have no impact until a new compression is started. * if nbWorkers>=1, new parameters will be picked up at next job, * with a few restrictions (windowLog, pledgedSrcSize, nbWorkers, jobSize, and overlapLog are not updated). */ ZSTDLIB_API size_t ZSTD_CCtx_setParametersUsingCCtxParams( ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params); /*=== Advanced parameters for decompression API ===*/ /* The following parameters must be set after creating a ZSTD_DCtx* (or ZSTD_DStream*) object, * but before starting decompression of a frame. */ /*! ZSTD_DCtx_loadDictionary() : * Create an internal DDict from dict buffer, * to be used to decompress next frames. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary, * meaning "return to no-dictionary mode". * Note 1 : `dict` content will be copied internally. * Use ZSTD_DCtx_loadDictionary_byReference() * to reference dictionary content instead. * In which case, the dictionary buffer must outlive its users. * Note 2 : Loading a dictionary involves building tables, * which has a non-negligible impact on CPU usage and latency. * Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to select * how dictionary content will be interpreted and loaded. */ ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize); ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize); ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType); /*! ZSTD_DCtx_refDDict() : * Reference a prepared dictionary, to be used to decompress next frames. * The dictionary remains active for decompression of future frames using same DCtx. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Note 1 : Currently, only one dictionary can be managed. * Referencing a new dictionary effectively "discards" any previous one. * Special : adding a NULL DDict means "return to no-dictionary mode". * Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx. */ ZSTDLIB_API size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict); /*! ZSTD_DCtx_refPrefix() : * Reference a prefix (single-usage dictionary) for next compression job. * Prefix is **only used once**. It must be explicitly referenced before each frame. * If there is a need to use same prefix multiple times, consider embedding it into a ZSTD_DDict instead. * @result : 0, or an error code (which can be tested with ZSTD_isError()). * Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary * Note 2 : Prefix buffer is referenced. It must outlive compression job. * Note 3 : By default, the prefix is treated as raw content (ZSTD_dm_rawContent). * Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode. * Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost. */ ZSTDLIB_API size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize); ZSTDLIB_API size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType); /*! ZSTD_DCtx_setMaxWindowSize() : * Refuses allocating internal buffers for frames requiring a window size larger than provided limit. * This is useful to prevent a decoder context from reserving too much memory for itself (potential attack scenario). * This parameter is only useful in streaming mode, since no internal buffer is allocated in direct mode. * By default, a decompression context accepts all window sizes <= (1 << ZSTD_WINDOWLOG_MAX) * @return : 0, or an error code (which can be tested using ZSTD_isError()). */ ZSTDLIB_API size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize); /*! ZSTD_DCtx_setFormat() : * Instruct the decoder context about what kind of data to decode next. * This instruction is mandatory to decode data without a fully-formed header, * such ZSTD_f_zstd1_magicless for example. * @return : 0, or an error code (which can be tested using ZSTD_isError()). */ ZSTDLIB_API size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format); /*! ZSTD_decompress_generic() : * Behave the same as ZSTD_decompressStream. * Decompression parameters cannot be changed once decompression is started. * @return : an error code, which can be tested using ZSTD_isError() * if >0, a hint, nb of expected input bytes for next invocation. * `0` means : a frame has just been fully decoded and flushed. */ ZSTDLIB_API size_t ZSTD_decompress_generic(ZSTD_DCtx* dctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input); /*! ZSTD_decompress_generic_simpleArgs() : * Same as ZSTD_decompress_generic(), * but using only integral types as arguments. * Argument list is larger than ZSTD_{in,out}Buffer, * but can be helpful for binders from dynamic languages * which have troubles handling structures containing memory pointers. */ ZSTDLIB_API size_t ZSTD_decompress_generic_simpleArgs ( ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, size_t* dstPos, const void* src, size_t srcSize, size_t* srcPos); /*! ZSTD_DCtx_reset() : * Return a DCtx to clean state. * If a decompression was ongoing, any internal data not yet flushed is cancelled. * All parameters are back to default values, including sticky ones. * Dictionary (if any) is dropped. * Parameters can be modified again after a reset. */ ZSTDLIB_API void ZSTD_DCtx_reset(ZSTD_DCtx* dctx); /* ============================ */ /** Block level API */ /* ============================ */ /*! Block functions produce and decode raw zstd blocks, without frame metadata. Frame metadata cost is typically ~18 bytes, which can be non-negligible for very small blocks (< 100 bytes). User will have to take in charge required information to regenerate data, such as compressed and content sizes. A few rules to respect : - Compressing and decompressing require a context structure + Use ZSTD_createCCtx() and ZSTD_createDCtx() - It is necessary to init context before starting + compression : any ZSTD_compressBegin*() variant, including with dictionary + decompression : any ZSTD_decompressBegin*() variant, including with dictionary + copyCCtx() and copyDCtx() can be used too - Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB + If input is larger than a block size, it's necessary to split input data into multiple blocks + For inputs larger than a single block size, consider using the regular ZSTD_compress() instead. Frame metadata is not that costly, and quickly becomes negligible as source size grows larger. - When a block is considered not compressible enough, ZSTD_compressBlock() result will be zero. In which case, nothing is produced into `dst`. + User must test for such outcome and deal directly with uncompressed data + ZSTD_decompressBlock() doesn't accept uncompressed data as input !!! + In case of multiple successive blocks, should some of them be uncompressed, decoder must be informed of their existence in order to follow proper history. Use ZSTD_insertBlock() for such a case. */ #define ZSTD_BLOCKSIZELOG_MAX 17 #define ZSTD_BLOCKSIZE_MAX (1< /* malloc, calloc, free */ #include /* memset */ #include "error_private.h" #include "zstd_internal.h" /*-**************************************** * Version ******************************************/ unsigned ZSTD_versionNumber(void) { return ZSTD_VERSION_NUMBER; } const char* ZSTD_versionString(void) { return ZSTD_VERSION_STRING; } /*-**************************************** * ZSTD Error Management ******************************************/ /*! ZSTD_isError() : * tells if a return value is an error code */ unsigned ZSTD_isError(size_t code) { return ERR_isError(code); } /*! ZSTD_getErrorName() : * provides error code string from function result (useful for debugging) */ const char* ZSTD_getErrorName(size_t code) { return ERR_getErrorName(code); } /*! ZSTD_getError() : * convert a `size_t` function result into a proper ZSTD_errorCode enum */ ZSTD_ErrorCode ZSTD_getErrorCode(size_t code) { return ERR_getErrorCode(code); } /*! ZSTD_getErrorString() : * provides error code string from enum */ const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorString(code); } /*! g_debuglog_enable : * turn on/off debug traces (global switch) */ #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 2) int g_debuglog_enable = 1; #endif /*=************************************************************** * Custom allocator ****************************************************************/ void* ZSTD_malloc(size_t size, ZSTD_customMem customMem) { if (customMem.customAlloc) return customMem.customAlloc(customMem.opaque, size); return malloc(size); } void* ZSTD_calloc(size_t size, ZSTD_customMem customMem) { if (customMem.customAlloc) { /* calloc implemented as malloc+memset; * not as efficient as calloc, but next best guess for custom malloc */ void* const ptr = customMem.customAlloc(customMem.opaque, size); memset(ptr, 0, size); return ptr; } return calloc(1, size); } void ZSTD_free(void* ptr, ZSTD_customMem customMem) { if (ptr!=NULL) { if (customMem.customFree) customMem.customFree(customMem.opaque, ptr); else free(ptr); } } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_compress.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /*-************************************* * Tuning parameters ***************************************/ #ifndef ZSTD_CLEVEL_DEFAULT # define ZSTD_CLEVEL_DEFAULT 3 #endif /*-************************************* * Dependencies ***************************************/ #include /* memset */ #include "cpu.h" #include "mem.h" #define FSE_STATIC_LINKING_ONLY /* FSE_encodeSymbol */ #include "fse.h" #define HUF_STATIC_LINKING_ONLY #include "huf.h" #include "zstd_compress_internal.h" #include "zstd_fast.h" #include "zstd_double_fast.h" #include "zstd_lazy.h" #include "zstd_opt.h" #include "zstd_ldm.h" /*-************************************* * Helper functions ***************************************/ size_t ZSTD_compressBound(size_t srcSize) { return ZSTD_COMPRESSBOUND(srcSize); } /*-************************************* * Context memory management ***************************************/ struct ZSTD_CDict_s { void* dictBuffer; const void* dictContent; size_t dictContentSize; void* workspace; size_t workspaceSize; ZSTD_matchState_t matchState; ZSTD_compressedBlockState_t cBlockState; ZSTD_compressionParameters cParams; ZSTD_customMem customMem; U32 dictID; }; /* typedef'd to ZSTD_CDict within "zstd.h" */ ZSTD_CCtx* ZSTD_createCCtx(void) { return ZSTD_createCCtx_advanced(ZSTD_defaultCMem); } ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem) { ZSTD_STATIC_ASSERT(zcss_init==0); ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN==(0ULL - 1)); if (!customMem.customAlloc ^ !customMem.customFree) return NULL; { ZSTD_CCtx* const cctx = (ZSTD_CCtx*)ZSTD_calloc(sizeof(ZSTD_CCtx), customMem); if (!cctx) return NULL; cctx->customMem = customMem; cctx->requestedParams.compressionLevel = ZSTD_CLEVEL_DEFAULT; cctx->requestedParams.fParams.contentSizeFlag = 1; cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid()); return cctx; } } ZSTD_CCtx* ZSTD_initStaticCCtx(void *workspace, size_t workspaceSize) { ZSTD_CCtx* const cctx = (ZSTD_CCtx*) workspace; if (workspaceSize <= sizeof(ZSTD_CCtx)) return NULL; /* minimum size */ if ((size_t)workspace & 7) return NULL; /* must be 8-aligned */ memset(workspace, 0, workspaceSize); /* may be a bit generous, could memset be smaller ? */ cctx->staticSize = workspaceSize; cctx->workSpace = (void*)(cctx+1); cctx->workSpaceSize = workspaceSize - sizeof(ZSTD_CCtx); /* statically sized space. entropyWorkspace never moves (but prev/next block swap places) */ if (cctx->workSpaceSize < HUF_WORKSPACE_SIZE + 2 * sizeof(ZSTD_compressedBlockState_t)) return NULL; assert(((size_t)cctx->workSpace & (sizeof(void*)-1)) == 0); /* ensure correct alignment */ cctx->blockState.prevCBlock = (ZSTD_compressedBlockState_t*)cctx->workSpace; cctx->blockState.nextCBlock = cctx->blockState.prevCBlock + 1; { void* const ptr = cctx->blockState.nextCBlock + 1; cctx->entropyWorkspace = (U32*)ptr; } cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid()); return cctx; } size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx) { if (cctx==NULL) return 0; /* support free on NULL */ if (cctx->staticSize) return ERROR(memory_allocation); /* not compatible with static CCtx */ ZSTD_free(cctx->workSpace, cctx->customMem); cctx->workSpace = NULL; ZSTD_freeCDict(cctx->cdictLocal); cctx->cdictLocal = NULL; #ifdef ZSTD_MULTITHREAD ZSTDMT_freeCCtx(cctx->mtctx); cctx->mtctx = NULL; #endif ZSTD_free(cctx, cctx->customMem); return 0; /* reserved as a potential error code in the future */ } static size_t ZSTD_sizeof_mtctx(const ZSTD_CCtx* cctx) { #ifdef ZSTD_MULTITHREAD return ZSTDMT_sizeof_CCtx(cctx->mtctx); #else (void) cctx; return 0; #endif } size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx) { if (cctx==NULL) return 0; /* support sizeof on NULL */ return sizeof(*cctx) + cctx->workSpaceSize + ZSTD_sizeof_CDict(cctx->cdictLocal) + ZSTD_sizeof_mtctx(cctx); } size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs) { return ZSTD_sizeof_CCtx(zcs); /* same object */ } /* private API call, for dictBuilder only */ const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx) { return &(ctx->seqStore); } ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams( const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize) { ZSTD_compressionParameters cParams = ZSTD_getCParams(CCtxParams->compressionLevel, srcSizeHint, dictSize); if (CCtxParams->ldmParams.enableLdm) cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG; if (CCtxParams->cParams.windowLog) cParams.windowLog = CCtxParams->cParams.windowLog; if (CCtxParams->cParams.hashLog) cParams.hashLog = CCtxParams->cParams.hashLog; if (CCtxParams->cParams.chainLog) cParams.chainLog = CCtxParams->cParams.chainLog; if (CCtxParams->cParams.searchLog) cParams.searchLog = CCtxParams->cParams.searchLog; if (CCtxParams->cParams.searchLength) cParams.searchLength = CCtxParams->cParams.searchLength; if (CCtxParams->cParams.targetLength) cParams.targetLength = CCtxParams->cParams.targetLength; if (CCtxParams->cParams.strategy) cParams.strategy = CCtxParams->cParams.strategy; return cParams; } static ZSTD_CCtx_params ZSTD_makeCCtxParamsFromCParams( ZSTD_compressionParameters cParams) { ZSTD_CCtx_params cctxParams; memset(&cctxParams, 0, sizeof(cctxParams)); cctxParams.cParams = cParams; cctxParams.compressionLevel = ZSTD_CLEVEL_DEFAULT; /* should not matter, as all cParams are presumed properly defined */ assert(!ZSTD_checkCParams(cParams)); cctxParams.fParams.contentSizeFlag = 1; return cctxParams; } static ZSTD_CCtx_params* ZSTD_createCCtxParams_advanced( ZSTD_customMem customMem) { ZSTD_CCtx_params* params; if (!customMem.customAlloc ^ !customMem.customFree) return NULL; params = (ZSTD_CCtx_params*)ZSTD_calloc( sizeof(ZSTD_CCtx_params), customMem); if (!params) { return NULL; } params->customMem = customMem; params->compressionLevel = ZSTD_CLEVEL_DEFAULT; params->fParams.contentSizeFlag = 1; return params; } ZSTD_CCtx_params* ZSTD_createCCtxParams(void) { return ZSTD_createCCtxParams_advanced(ZSTD_defaultCMem); } size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params) { if (params == NULL) { return 0; } ZSTD_free(params, params->customMem); return 0; } size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params) { return ZSTD_CCtxParams_init(params, ZSTD_CLEVEL_DEFAULT); } size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel) { if (!cctxParams) { return ERROR(GENERIC); } memset(cctxParams, 0, sizeof(*cctxParams)); cctxParams->compressionLevel = compressionLevel; cctxParams->fParams.contentSizeFlag = 1; return 0; } size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params) { if (!cctxParams) { return ERROR(GENERIC); } CHECK_F( ZSTD_checkCParams(params.cParams) ); memset(cctxParams, 0, sizeof(*cctxParams)); cctxParams->cParams = params.cParams; cctxParams->fParams = params.fParams; cctxParams->compressionLevel = ZSTD_CLEVEL_DEFAULT; /* should not matter, as all cParams are presumed properly defined */ assert(!ZSTD_checkCParams(params.cParams)); return 0; } /* ZSTD_assignParamsToCCtxParams() : * params is presumed valid at this stage */ static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams( ZSTD_CCtx_params cctxParams, ZSTD_parameters params) { ZSTD_CCtx_params ret = cctxParams; ret.cParams = params.cParams; ret.fParams = params.fParams; ret.compressionLevel = ZSTD_CLEVEL_DEFAULT; /* should not matter, as all cParams are presumed properly defined */ assert(!ZSTD_checkCParams(params.cParams)); return ret; } #define CLAMPCHECK(val,min,max) { \ if (((val)<(min)) | ((val)>(max))) { \ return ERROR(parameter_outOfBound); \ } } static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param) { switch(param) { case ZSTD_p_compressionLevel: case ZSTD_p_hashLog: case ZSTD_p_chainLog: case ZSTD_p_searchLog: case ZSTD_p_minMatch: case ZSTD_p_targetLength: case ZSTD_p_compressionStrategy: case ZSTD_p_compressLiterals: return 1; case ZSTD_p_format: case ZSTD_p_windowLog: case ZSTD_p_contentSizeFlag: case ZSTD_p_checksumFlag: case ZSTD_p_dictIDFlag: case ZSTD_p_forceMaxWindow : case ZSTD_p_nbWorkers: case ZSTD_p_jobSize: case ZSTD_p_overlapSizeLog: case ZSTD_p_enableLongDistanceMatching: case ZSTD_p_ldmHashLog: case ZSTD_p_ldmMinMatch: case ZSTD_p_ldmBucketSizeLog: case ZSTD_p_ldmHashEveryLog: default: return 0; } } size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned value) { DEBUGLOG(4, "ZSTD_CCtx_setParameter (%u, %u)", (U32)param, value); if (cctx->streamStage != zcss_init) { if (ZSTD_isUpdateAuthorized(param)) { cctx->cParamsChanged = 1; } else { return ERROR(stage_wrong); } } switch(param) { case ZSTD_p_format : return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); case ZSTD_p_compressionLevel: if (cctx->cdict) return ERROR(stage_wrong); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); case ZSTD_p_windowLog: case ZSTD_p_hashLog: case ZSTD_p_chainLog: case ZSTD_p_searchLog: case ZSTD_p_minMatch: case ZSTD_p_targetLength: case ZSTD_p_compressionStrategy: if (cctx->cdict) return ERROR(stage_wrong); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); case ZSTD_p_compressLiterals: case ZSTD_p_contentSizeFlag: case ZSTD_p_checksumFlag: case ZSTD_p_dictIDFlag: return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); case ZSTD_p_forceMaxWindow : /* Force back-references to remain < windowSize, * even when referencing into Dictionary content. * default : 0 when using a CDict, 1 when using a Prefix */ return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); case ZSTD_p_nbWorkers: if ((value>0) && cctx->staticSize) { return ERROR(parameter_unsupported); /* MT not compatible with static alloc */ } return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); case ZSTD_p_jobSize: case ZSTD_p_overlapSizeLog: return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); case ZSTD_p_enableLongDistanceMatching: case ZSTD_p_ldmHashLog: case ZSTD_p_ldmMinMatch: case ZSTD_p_ldmBucketSizeLog: case ZSTD_p_ldmHashEveryLog: if (cctx->cdict) return ERROR(stage_wrong); return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value); default: return ERROR(parameter_unsupported); } } size_t ZSTD_CCtxParam_setParameter( ZSTD_CCtx_params* CCtxParams, ZSTD_cParameter param, unsigned value) { DEBUGLOG(4, "ZSTD_CCtxParam_setParameter (%u, %u)", (U32)param, value); switch(param) { case ZSTD_p_format : if (value > (unsigned)ZSTD_f_zstd1_magicless) return ERROR(parameter_unsupported); CCtxParams->format = (ZSTD_format_e)value; return (size_t)CCtxParams->format; case ZSTD_p_compressionLevel : { int cLevel = (int)value; /* cast expected to restore negative sign */ if (cLevel > ZSTD_maxCLevel()) cLevel = ZSTD_maxCLevel(); if (cLevel) { /* 0 : does not change current level */ CCtxParams->disableLiteralCompression = (cLevel<0); /* negative levels disable huffman */ CCtxParams->compressionLevel = cLevel; } if (CCtxParams->compressionLevel >= 0) return CCtxParams->compressionLevel; return 0; /* return type (size_t) cannot represent negative values */ } case ZSTD_p_windowLog : if (value>0) /* 0 => use default */ CLAMPCHECK(value, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX); CCtxParams->cParams.windowLog = value; return CCtxParams->cParams.windowLog; case ZSTD_p_hashLog : if (value>0) /* 0 => use default */ CLAMPCHECK(value, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX); CCtxParams->cParams.hashLog = value; return CCtxParams->cParams.hashLog; case ZSTD_p_chainLog : if (value>0) /* 0 => use default */ CLAMPCHECK(value, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX); CCtxParams->cParams.chainLog = value; return CCtxParams->cParams.chainLog; case ZSTD_p_searchLog : if (value>0) /* 0 => use default */ CLAMPCHECK(value, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX); CCtxParams->cParams.searchLog = value; return value; case ZSTD_p_minMatch : if (value>0) /* 0 => use default */ CLAMPCHECK(value, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX); CCtxParams->cParams.searchLength = value; return CCtxParams->cParams.searchLength; case ZSTD_p_targetLength : /* all values are valid. 0 => use default */ CCtxParams->cParams.targetLength = value; return CCtxParams->cParams.targetLength; case ZSTD_p_compressionStrategy : if (value>0) /* 0 => use default */ CLAMPCHECK(value, (unsigned)ZSTD_fast, (unsigned)ZSTD_btultra); CCtxParams->cParams.strategy = (ZSTD_strategy)value; return (size_t)CCtxParams->cParams.strategy; case ZSTD_p_compressLiterals: CCtxParams->disableLiteralCompression = !value; return !CCtxParams->disableLiteralCompression; case ZSTD_p_contentSizeFlag : /* Content size written in frame header _when known_ (default:1) */ DEBUGLOG(4, "set content size flag = %u", (value>0)); CCtxParams->fParams.contentSizeFlag = value > 0; return CCtxParams->fParams.contentSizeFlag; case ZSTD_p_checksumFlag : /* A 32-bits content checksum will be calculated and written at end of frame (default:0) */ CCtxParams->fParams.checksumFlag = value > 0; return CCtxParams->fParams.checksumFlag; case ZSTD_p_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */ DEBUGLOG(4, "set dictIDFlag = %u", (value>0)); CCtxParams->fParams.noDictIDFlag = !value; return !CCtxParams->fParams.noDictIDFlag; case ZSTD_p_forceMaxWindow : CCtxParams->forceWindow = (value > 0); return CCtxParams->forceWindow; case ZSTD_p_nbWorkers : #ifndef ZSTD_MULTITHREAD if (value>0) return ERROR(parameter_unsupported); return 0; #else return ZSTDMT_CCtxParam_setNbWorkers(CCtxParams, value); #endif case ZSTD_p_jobSize : #ifndef ZSTD_MULTITHREAD return ERROR(parameter_unsupported); #else return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_jobSize, value); #endif case ZSTD_p_overlapSizeLog : #ifndef ZSTD_MULTITHREAD return ERROR(parameter_unsupported); #else return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_overlapSectionLog, value); #endif case ZSTD_p_enableLongDistanceMatching : CCtxParams->ldmParams.enableLdm = (value>0); return CCtxParams->ldmParams.enableLdm; case ZSTD_p_ldmHashLog : if (value>0) /* 0 ==> auto */ CLAMPCHECK(value, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX); CCtxParams->ldmParams.hashLog = value; return CCtxParams->ldmParams.hashLog; case ZSTD_p_ldmMinMatch : if (value>0) /* 0 ==> default */ CLAMPCHECK(value, ZSTD_LDM_MINMATCH_MIN, ZSTD_LDM_MINMATCH_MAX); CCtxParams->ldmParams.minMatchLength = value; return CCtxParams->ldmParams.minMatchLength; case ZSTD_p_ldmBucketSizeLog : if (value > ZSTD_LDM_BUCKETSIZELOG_MAX) return ERROR(parameter_outOfBound); CCtxParams->ldmParams.bucketSizeLog = value; return CCtxParams->ldmParams.bucketSizeLog; case ZSTD_p_ldmHashEveryLog : if (value > ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN) return ERROR(parameter_outOfBound); CCtxParams->ldmParams.hashEveryLog = value; return CCtxParams->ldmParams.hashEveryLog; default: return ERROR(parameter_unsupported); } } /** ZSTD_CCtx_setParametersUsingCCtxParams() : * just applies `params` into `cctx` * no action is performed, parameters are merely stored. * If ZSTDMT is enabled, parameters are pushed to cctx->mtctx. * This is possible even if a compression is ongoing. * In which case, new parameters will be applied on the fly, starting with next compression job. */ size_t ZSTD_CCtx_setParametersUsingCCtxParams( ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params) { if (cctx->streamStage != zcss_init) return ERROR(stage_wrong); if (cctx->cdict) return ERROR(stage_wrong); cctx->requestedParams = *params; return 0; } ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize) { DEBUGLOG(4, "ZSTD_CCtx_setPledgedSrcSize to %u bytes", (U32)pledgedSrcSize); if (cctx->streamStage != zcss_init) return ERROR(stage_wrong); cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1; return 0; } size_t ZSTD_CCtx_loadDictionary_advanced( ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType) { if (cctx->streamStage != zcss_init) return ERROR(stage_wrong); if (cctx->staticSize) return ERROR(memory_allocation); /* no malloc for static CCtx */ DEBUGLOG(4, "ZSTD_CCtx_loadDictionary_advanced (size: %u)", (U32)dictSize); ZSTD_freeCDict(cctx->cdictLocal); /* in case one already exists */ if (dict==NULL || dictSize==0) { /* no dictionary mode */ cctx->cdictLocal = NULL; cctx->cdict = NULL; } else { ZSTD_compressionParameters const cParams = ZSTD_getCParamsFromCCtxParams(&cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, dictSize); cctx->cdictLocal = ZSTD_createCDict_advanced( dict, dictSize, dictLoadMethod, dictContentType, cParams, cctx->customMem); cctx->cdict = cctx->cdictLocal; if (cctx->cdictLocal == NULL) return ERROR(memory_allocation); } return 0; } ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary_byReference( ZSTD_CCtx* cctx, const void* dict, size_t dictSize) { return ZSTD_CCtx_loadDictionary_advanced( cctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto); } ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize) { return ZSTD_CCtx_loadDictionary_advanced( cctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto); } size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict) { if (cctx->streamStage != zcss_init) return ERROR(stage_wrong); cctx->cdict = cdict; memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict)); /* exclusive */ return 0; } size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize) { return ZSTD_CCtx_refPrefix_advanced(cctx, prefix, prefixSize, ZSTD_dct_rawContent); } size_t ZSTD_CCtx_refPrefix_advanced( ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType) { if (cctx->streamStage != zcss_init) return ERROR(stage_wrong); cctx->cdict = NULL; /* prefix discards any prior cdict */ cctx->prefixDict.dict = prefix; cctx->prefixDict.dictSize = prefixSize; cctx->prefixDict.dictContentType = dictContentType; return 0; } static void ZSTD_startNewCompression(ZSTD_CCtx* cctx) { cctx->streamStage = zcss_init; cctx->pledgedSrcSizePlusOne = 0; } /*! ZSTD_CCtx_reset() : * Also dumps dictionary */ void ZSTD_CCtx_reset(ZSTD_CCtx* cctx) { ZSTD_startNewCompression(cctx); cctx->cdict = NULL; } /** ZSTD_checkCParams() : control CParam values remain within authorized range. @return : 0, or an error code if one value is beyond authorized range */ size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams) { CLAMPCHECK(cParams.windowLog, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX); CLAMPCHECK(cParams.chainLog, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX); CLAMPCHECK(cParams.hashLog, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX); CLAMPCHECK(cParams.searchLog, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX); CLAMPCHECK(cParams.searchLength, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX); if ((U32)(cParams.targetLength) < ZSTD_TARGETLENGTH_MIN) return ERROR(parameter_unsupported); if ((U32)(cParams.strategy) > (U32)ZSTD_btultra) return ERROR(parameter_unsupported); return 0; } /** ZSTD_clampCParams() : * make CParam values within valid range. * @return : valid CParams */ static ZSTD_compressionParameters ZSTD_clampCParams(ZSTD_compressionParameters cParams) { # define CLAMP(val,min,max) { \ if (valmax) val=max; \ } CLAMP(cParams.windowLog, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX); CLAMP(cParams.chainLog, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX); CLAMP(cParams.hashLog, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX); CLAMP(cParams.searchLog, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX); CLAMP(cParams.searchLength, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX); if ((U32)(cParams.targetLength) < ZSTD_TARGETLENGTH_MIN) cParams.targetLength = ZSTD_TARGETLENGTH_MIN; if ((U32)(cParams.strategy) > (U32)ZSTD_btultra) cParams.strategy = ZSTD_btultra; return cParams; } /** ZSTD_cycleLog() : * condition for correct operation : hashLog > 1 */ static U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat) { U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2); return hashLog - btScale; } /** ZSTD_adjustCParams_internal() : optimize `cPar` for a given input (`srcSize` and `dictSize`). mostly downsizing to reduce memory consumption and initialization latency. Both `srcSize` and `dictSize` are optional (use 0 if unknown). Note : cPar is considered validated at this stage. Use ZSTD_checkCParams() to ensure that condition. */ ZSTD_compressionParameters ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize) { static const U64 minSrcSize = 513; /* (1<<9) + 1 */ static const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1); assert(ZSTD_checkCParams(cPar)==0); if (dictSize && (srcSize+1<2) /* srcSize unknown */ ) srcSize = minSrcSize; /* presumed small when there is a dictionary */ else if (srcSize == 0) srcSize = ZSTD_CONTENTSIZE_UNKNOWN; /* 0 == unknown : presumed large */ /* resize windowLog if input is small enough, to use less memory */ if ( (srcSize < maxWindowResize) && (dictSize < maxWindowResize) ) { U32 const tSize = (U32)(srcSize + dictSize); static U32 const hashSizeMin = 1 << ZSTD_HASHLOG_MIN; U32 const srcLog = (tSize < hashSizeMin) ? ZSTD_HASHLOG_MIN : ZSTD_highbit32(tSize-1) + 1; if (cPar.windowLog > srcLog) cPar.windowLog = srcLog; } if (cPar.hashLog > cPar.windowLog) cPar.hashLog = cPar.windowLog; { U32 const cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy); if (cycleLog > cPar.windowLog) cPar.chainLog -= (cycleLog - cPar.windowLog); } if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN) cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN; /* required for frame header */ return cPar; } ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize) { cPar = ZSTD_clampCParams(cPar); return ZSTD_adjustCParams_internal(cPar, srcSize, dictSize); } static size_t ZSTD_sizeof_matchState(ZSTD_compressionParameters const* cParams, const U32 forCCtx) { size_t const chainSize = (cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cParams->chainLog); size_t const hSize = ((size_t)1) << cParams->hashLog; U32 const hashLog3 = (forCCtx && cParams->searchLength==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0; size_t const h3Size = ((size_t)1) << hashLog3; size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32); size_t const optPotentialSpace = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<strategy == ZSTD_btopt) || (cParams->strategy == ZSTD_btultra))) ? optPotentialSpace : 0; DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u", (U32)chainSize, (U32)hSize, (U32)h3Size); return tableSpace + optSpace; } size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params) { /* Estimate CCtx size is supported for single-threaded compression only. */ if (params->nbWorkers > 0) { return ERROR(GENERIC); } { ZSTD_compressionParameters const cParams = ZSTD_getCParamsFromCCtxParams(params, 0, 0); size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog); U32 const divider = (cParams.searchLength==3) ? 3 : 4; size_t const maxNbSeq = blockSize / divider; size_t const tokenSpace = blockSize + 11*maxNbSeq; size_t const entropySpace = HUF_WORKSPACE_SIZE; size_t const blockStateSpace = 2 * sizeof(ZSTD_compressedBlockState_t); size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 1); size_t const ldmSpace = ZSTD_ldm_getTableSize(params->ldmParams); size_t const ldmSeqSpace = ZSTD_ldm_getMaxNbSeq(params->ldmParams, blockSize) * sizeof(rawSeq); size_t const neededSpace = entropySpace + blockStateSpace + tokenSpace + matchStateSize + ldmSpace + ldmSeqSpace; DEBUGLOG(5, "sizeof(ZSTD_CCtx) : %u", (U32)sizeof(ZSTD_CCtx)); DEBUGLOG(5, "estimate workSpace : %u", (U32)neededSpace); return sizeof(ZSTD_CCtx) + neededSpace; } } size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams) { ZSTD_CCtx_params const params = ZSTD_makeCCtxParamsFromCParams(cParams); return ZSTD_estimateCCtxSize_usingCCtxParams(¶ms); } static size_t ZSTD_estimateCCtxSize_internal(int compressionLevel) { ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, 0); return ZSTD_estimateCCtxSize_usingCParams(cParams); } size_t ZSTD_estimateCCtxSize(int compressionLevel) { int level; size_t memBudget = 0; for (level=1; level<=compressionLevel; level++) { size_t const newMB = ZSTD_estimateCCtxSize_internal(level); if (newMB > memBudget) memBudget = newMB; } return memBudget; } size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params) { if (params->nbWorkers > 0) { return ERROR(GENERIC); } { size_t const CCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(params); size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << params->cParams.windowLog); size_t const inBuffSize = ((size_t)1 << params->cParams.windowLog) + blockSize; size_t const outBuffSize = ZSTD_compressBound(blockSize) + 1; size_t const streamingSize = inBuffSize + outBuffSize; return CCtxSize + streamingSize; } } size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams) { ZSTD_CCtx_params const params = ZSTD_makeCCtxParamsFromCParams(cParams); return ZSTD_estimateCStreamSize_usingCCtxParams(¶ms); } static size_t ZSTD_estimateCStreamSize_internal(int compressionLevel) { ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, 0); return ZSTD_estimateCStreamSize_usingCParams(cParams); } size_t ZSTD_estimateCStreamSize(int compressionLevel) { int level; size_t memBudget = 0; for (level=1; level<=compressionLevel; level++) { size_t const newMB = ZSTD_estimateCStreamSize_internal(level); if (newMB > memBudget) memBudget = newMB; } return memBudget; } /* ZSTD_getFrameProgression(): * tells how much data has been consumed (input) and produced (output) for current frame. * able to count progression inside worker threads (non-blocking mode). */ ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx) { #ifdef ZSTD_MULTITHREAD if (cctx->appliedParams.nbWorkers > 0) { return ZSTDMT_getFrameProgression(cctx->mtctx); } #endif { ZSTD_frameProgression fp; size_t const buffered = (cctx->inBuff == NULL) ? 0 : cctx->inBuffPos - cctx->inToCompress; if (buffered) assert(cctx->inBuffPos >= cctx->inToCompress); assert(buffered <= ZSTD_BLOCKSIZE_MAX); fp.ingested = cctx->consumedSrcSize + buffered; fp.consumed = cctx->consumedSrcSize; fp.produced = cctx->producedCSize; return fp; } } static U32 ZSTD_equivalentCParams(ZSTD_compressionParameters cParams1, ZSTD_compressionParameters cParams2) { return (cParams1.hashLog == cParams2.hashLog) & (cParams1.chainLog == cParams2.chainLog) & (cParams1.strategy == cParams2.strategy) /* opt parser space */ & ((cParams1.searchLength==3) == (cParams2.searchLength==3)); /* hashlog3 space */ } /** The parameters are equivalent if ldm is not enabled in both sets or * all the parameters are equivalent. */ static U32 ZSTD_equivalentLdmParams(ldmParams_t ldmParams1, ldmParams_t ldmParams2) { return (!ldmParams1.enableLdm && !ldmParams2.enableLdm) || (ldmParams1.enableLdm == ldmParams2.enableLdm && ldmParams1.hashLog == ldmParams2.hashLog && ldmParams1.bucketSizeLog == ldmParams2.bucketSizeLog && ldmParams1.minMatchLength == ldmParams2.minMatchLength && ldmParams1.hashEveryLog == ldmParams2.hashEveryLog); } typedef enum { ZSTDb_not_buffered, ZSTDb_buffered } ZSTD_buffered_policy_e; /* ZSTD_sufficientBuff() : * check internal buffers exist for streaming if buffPol == ZSTDb_buffered . * Note : they are assumed to be correctly sized if ZSTD_equivalentCParams()==1 */ static U32 ZSTD_sufficientBuff(size_t bufferSize1, size_t blockSize1, ZSTD_buffered_policy_e buffPol2, ZSTD_compressionParameters cParams2, U64 pledgedSrcSize) { size_t const windowSize2 = MAX(1, (size_t)MIN(((U64)1 << cParams2.windowLog), pledgedSrcSize)); size_t const blockSize2 = MIN(ZSTD_BLOCKSIZE_MAX, windowSize2); size_t const neededBufferSize2 = (buffPol2==ZSTDb_buffered) ? windowSize2 + blockSize2 : 0; DEBUGLOG(4, "ZSTD_sufficientBuff: is windowSize2=%u <= wlog1=%u", (U32)windowSize2, cParams2.windowLog); DEBUGLOG(4, "ZSTD_sufficientBuff: is blockSize2=%u <= blockSize1=%u", (U32)blockSize2, (U32)blockSize1); return (blockSize2 <= blockSize1) /* seqStore space depends on blockSize */ & (neededBufferSize2 <= bufferSize1); } /** Equivalence for resetCCtx purposes */ static U32 ZSTD_equivalentParams(ZSTD_CCtx_params params1, ZSTD_CCtx_params params2, size_t buffSize1, size_t blockSize1, ZSTD_buffered_policy_e buffPol2, U64 pledgedSrcSize) { DEBUGLOG(4, "ZSTD_equivalentParams: pledgedSrcSize=%u", (U32)pledgedSrcSize); return ZSTD_equivalentCParams(params1.cParams, params2.cParams) && ZSTD_equivalentLdmParams(params1.ldmParams, params2.ldmParams) && ZSTD_sufficientBuff(buffSize1, blockSize1, buffPol2, params2.cParams, pledgedSrcSize); } static void ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs) { int i; for (i = 0; i < ZSTD_REP_NUM; ++i) bs->rep[i] = repStartValue[i]; bs->entropy.hufCTable_repeatMode = HUF_repeat_none; bs->entropy.offcode_repeatMode = FSE_repeat_none; bs->entropy.matchlength_repeatMode = FSE_repeat_none; bs->entropy.litlength_repeatMode = FSE_repeat_none; } /*! ZSTD_invalidateMatchState() * Invalidate all the matches in the match finder tables. * Requires nextSrc and base to be set (can be NULL). */ static void ZSTD_invalidateMatchState(ZSTD_matchState_t* ms) { ZSTD_window_clear(&ms->window); ms->nextToUpdate = ms->window.dictLimit + 1; ms->loadedDictEnd = 0; ms->opt.litLengthSum = 0; /* force reset of btopt stats */ } /*! ZSTD_continueCCtx() : * reuse CCtx without reset (note : requires no dictionary) */ static size_t ZSTD_continueCCtx(ZSTD_CCtx* cctx, ZSTD_CCtx_params params, U64 pledgedSrcSize) { size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params.cParams.windowLog), pledgedSrcSize)); size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, windowSize); DEBUGLOG(4, "ZSTD_continueCCtx: re-use context in place"); cctx->blockSize = blockSize; /* previous block size could be different even for same windowLog, due to pledgedSrcSize */ cctx->appliedParams = params; cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1; cctx->consumedSrcSize = 0; cctx->producedCSize = 0; if (pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN) cctx->appliedParams.fParams.contentSizeFlag = 0; DEBUGLOG(4, "pledged content size : %u ; flag : %u", (U32)pledgedSrcSize, cctx->appliedParams.fParams.contentSizeFlag); cctx->stage = ZSTDcs_init; cctx->dictID = 0; if (params.ldmParams.enableLdm) ZSTD_window_clear(&cctx->ldmState.window); ZSTD_referenceExternalSequences(cctx, NULL, 0); ZSTD_invalidateMatchState(&cctx->blockState.matchState); ZSTD_reset_compressedBlockState(cctx->blockState.prevCBlock); XXH64_reset(&cctx->xxhState, 0); return 0; } typedef enum { ZSTDcrp_continue, ZSTDcrp_noMemset } ZSTD_compResetPolicy_e; static void* ZSTD_reset_matchState(ZSTD_matchState_t* ms, void* ptr, ZSTD_compressionParameters const* cParams, ZSTD_compResetPolicy_e const crp, U32 const forCCtx) { size_t const chainSize = (cParams->strategy == ZSTD_fast) ? 0 : ((size_t)1 << cParams->chainLog); size_t const hSize = ((size_t)1) << cParams->hashLog; U32 const hashLog3 = (forCCtx && cParams->searchLength==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0; size_t const h3Size = ((size_t)1) << hashLog3; size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32); assert(((size_t)ptr & 3) == 0); ms->hashLog3 = hashLog3; memset(&ms->window, 0, sizeof(ms->window)); ZSTD_invalidateMatchState(ms); /* opt parser space */ if (forCCtx && ((cParams->strategy == ZSTD_btopt) | (cParams->strategy == ZSTD_btultra))) { DEBUGLOG(4, "reserving optimal parser space"); ms->opt.litFreq = (U32*)ptr; ms->opt.litLengthFreq = ms->opt.litFreq + (1<opt.matchLengthFreq = ms->opt.litLengthFreq + (MaxLL+1); ms->opt.offCodeFreq = ms->opt.matchLengthFreq + (MaxML+1); ptr = ms->opt.offCodeFreq + (MaxOff+1); ms->opt.matchTable = (ZSTD_match_t*)ptr; ptr = ms->opt.matchTable + ZSTD_OPT_NUM+1; ms->opt.priceTable = (ZSTD_optimal_t*)ptr; ptr = ms->opt.priceTable + ZSTD_OPT_NUM+1; } /* table Space */ DEBUGLOG(4, "reset table : %u", crp!=ZSTDcrp_noMemset); assert(((size_t)ptr & 3) == 0); /* ensure ptr is properly aligned */ if (crp!=ZSTDcrp_noMemset) memset(ptr, 0, tableSpace); /* reset tables only */ ms->hashTable = (U32*)(ptr); ms->chainTable = ms->hashTable + hSize; ms->hashTable3 = ms->chainTable + chainSize; ptr = ms->hashTable3 + h3Size; assert(((size_t)ptr & 3) == 0); return ptr; } /*! ZSTD_resetCCtx_internal() : note : `params` are assumed fully validated at this stage */ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc, ZSTD_CCtx_params params, U64 pledgedSrcSize, ZSTD_compResetPolicy_e const crp, ZSTD_buffered_policy_e const zbuff) { DEBUGLOG(4, "ZSTD_resetCCtx_internal: pledgedSrcSize=%u, wlog=%u", (U32)pledgedSrcSize, params.cParams.windowLog); assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams))); if (crp == ZSTDcrp_continue) { if (ZSTD_equivalentParams(zc->appliedParams, params, zc->inBuffSize, zc->blockSize, zbuff, pledgedSrcSize)) { DEBUGLOG(4, "ZSTD_equivalentParams()==1 -> continue mode (wLog1=%u, blockSize1=%u)", zc->appliedParams.cParams.windowLog, (U32)zc->blockSize); return ZSTD_continueCCtx(zc, params, pledgedSrcSize); } } DEBUGLOG(4, "ZSTD_equivalentParams()==0 -> reset CCtx"); if (params.ldmParams.enableLdm) { /* Adjust long distance matching parameters */ params.ldmParams.windowLog = params.cParams.windowLog; ZSTD_ldm_adjustParameters(¶ms.ldmParams, ¶ms.cParams); assert(params.ldmParams.hashLog >= params.ldmParams.bucketSizeLog); assert(params.ldmParams.hashEveryLog < 32); zc->ldmState.hashPower = ZSTD_ldm_getHashPower(params.ldmParams.minMatchLength); } { size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params.cParams.windowLog), pledgedSrcSize)); size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, windowSize); U32 const divider = (params.cParams.searchLength==3) ? 3 : 4; size_t const maxNbSeq = blockSize / divider; size_t const tokenSpace = blockSize + 11*maxNbSeq; size_t const buffOutSize = (zbuff==ZSTDb_buffered) ? ZSTD_compressBound(blockSize)+1 : 0; size_t const buffInSize = (zbuff==ZSTDb_buffered) ? windowSize + blockSize : 0; size_t const matchStateSize = ZSTD_sizeof_matchState(¶ms.cParams, /* forCCtx */ 1); size_t const maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(params.ldmParams, blockSize); void* ptr; /* Check if workSpace is large enough, alloc a new one if needed */ { size_t const entropySpace = HUF_WORKSPACE_SIZE; size_t const blockStateSpace = 2 * sizeof(ZSTD_compressedBlockState_t); size_t const bufferSpace = buffInSize + buffOutSize; size_t const ldmSpace = ZSTD_ldm_getTableSize(params.ldmParams); size_t const ldmSeqSpace = maxNbLdmSeq * sizeof(rawSeq); size_t const neededSpace = entropySpace + blockStateSpace + ldmSpace + ldmSeqSpace + matchStateSize + tokenSpace + bufferSpace; DEBUGLOG(4, "Need %uKB workspace, including %uKB for match state, and %uKB for buffers", (U32)(neededSpace>>10), (U32)(matchStateSize>>10), (U32)(bufferSpace>>10)); DEBUGLOG(4, "windowSize: %u - blockSize: %u", (U32)windowSize, (U32)blockSize); if (zc->workSpaceSize < neededSpace) { /* too small : resize */ DEBUGLOG(4, "Need to update workSpaceSize from %uK to %uK", (unsigned)(zc->workSpaceSize>>10), (unsigned)(neededSpace>>10)); /* static cctx : no resize, error out */ if (zc->staticSize) return ERROR(memory_allocation); zc->workSpaceSize = 0; ZSTD_free(zc->workSpace, zc->customMem); zc->workSpace = ZSTD_malloc(neededSpace, zc->customMem); if (zc->workSpace == NULL) return ERROR(memory_allocation); zc->workSpaceSize = neededSpace; ptr = zc->workSpace; /* Statically sized space. entropyWorkspace never moves (but prev/next block swap places) */ assert(((size_t)zc->workSpace & 3) == 0); /* ensure correct alignment */ assert(zc->workSpaceSize >= 2 * sizeof(ZSTD_compressedBlockState_t)); zc->blockState.prevCBlock = (ZSTD_compressedBlockState_t*)zc->workSpace; zc->blockState.nextCBlock = zc->blockState.prevCBlock + 1; ptr = zc->blockState.nextCBlock + 1; zc->entropyWorkspace = (U32*)ptr; } } /* init params */ zc->appliedParams = params; zc->pledgedSrcSizePlusOne = pledgedSrcSize+1; zc->consumedSrcSize = 0; zc->producedCSize = 0; if (pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN) zc->appliedParams.fParams.contentSizeFlag = 0; DEBUGLOG(4, "pledged content size : %u ; flag : %u", (U32)pledgedSrcSize, zc->appliedParams.fParams.contentSizeFlag); zc->blockSize = blockSize; XXH64_reset(&zc->xxhState, 0); zc->stage = ZSTDcs_init; zc->dictID = 0; ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock); ptr = zc->entropyWorkspace + HUF_WORKSPACE_SIZE_U32; /* ldm hash table */ /* initialize bucketOffsets table later for pointer alignment */ if (params.ldmParams.enableLdm) { size_t const ldmHSize = ((size_t)1) << params.ldmParams.hashLog; memset(ptr, 0, ldmHSize * sizeof(ldmEntry_t)); assert(((size_t)ptr & 3) == 0); /* ensure ptr is properly aligned */ zc->ldmState.hashTable = (ldmEntry_t*)ptr; ptr = zc->ldmState.hashTable + ldmHSize; zc->ldmSequences = (rawSeq*)ptr; ptr = zc->ldmSequences + maxNbLdmSeq; zc->maxNbLdmSequences = maxNbLdmSeq; memset(&zc->ldmState.window, 0, sizeof(zc->ldmState.window)); } assert(((size_t)ptr & 3) == 0); /* ensure ptr is properly aligned */ ptr = ZSTD_reset_matchState(&zc->blockState.matchState, ptr, ¶ms.cParams, crp, /* forCCtx */ 1); /* sequences storage */ zc->seqStore.sequencesStart = (seqDef*)ptr; ptr = zc->seqStore.sequencesStart + maxNbSeq; zc->seqStore.llCode = (BYTE*) ptr; zc->seqStore.mlCode = zc->seqStore.llCode + maxNbSeq; zc->seqStore.ofCode = zc->seqStore.mlCode + maxNbSeq; zc->seqStore.litStart = zc->seqStore.ofCode + maxNbSeq; ptr = zc->seqStore.litStart + blockSize; /* ldm bucketOffsets table */ if (params.ldmParams.enableLdm) { size_t const ldmBucketSize = ((size_t)1) << (params.ldmParams.hashLog - params.ldmParams.bucketSizeLog); memset(ptr, 0, ldmBucketSize); zc->ldmState.bucketOffsets = (BYTE*)ptr; ptr = zc->ldmState.bucketOffsets + ldmBucketSize; ZSTD_window_clear(&zc->ldmState.window); } ZSTD_referenceExternalSequences(zc, NULL, 0); /* buffers */ zc->inBuffSize = buffInSize; zc->inBuff = (char*)ptr; zc->outBuffSize = buffOutSize; zc->outBuff = zc->inBuff + buffInSize; return 0; } } /* ZSTD_invalidateRepCodes() : * ensures next compression will not use repcodes from previous block. * Note : only works with regular variant; * do not use with extDict variant ! */ void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) { int i; for (i=0; iblockState.prevCBlock->rep[i] = 0; assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window)); } static size_t ZSTD_resetCCtx_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict, unsigned windowLog, ZSTD_frameParameters fParams, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff) { { ZSTD_CCtx_params params = cctx->requestedParams; /* Copy only compression parameters related to tables. */ params.cParams = cdict->cParams; if (windowLog) params.cParams.windowLog = windowLog; params.fParams = fParams; ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize, ZSTDcrp_noMemset, zbuff); assert(cctx->appliedParams.cParams.strategy == cdict->cParams.strategy); assert(cctx->appliedParams.cParams.hashLog == cdict->cParams.hashLog); assert(cctx->appliedParams.cParams.chainLog == cdict->cParams.chainLog); } /* copy tables */ { size_t const chainSize = (cdict->cParams.strategy == ZSTD_fast) ? 0 : ((size_t)1 << cdict->cParams.chainLog); size_t const hSize = (size_t)1 << cdict->cParams.hashLog; size_t const tableSpace = (chainSize + hSize) * sizeof(U32); assert((U32*)cctx->blockState.matchState.chainTable == (U32*)cctx->blockState.matchState.hashTable + hSize); /* chainTable must follow hashTable */ assert((U32*)cctx->blockState.matchState.hashTable3 == (U32*)cctx->blockState.matchState.chainTable + chainSize); assert((U32*)cdict->matchState.chainTable == (U32*)cdict->matchState.hashTable + hSize); /* chainTable must follow hashTable */ assert((U32*)cdict->matchState.hashTable3 == (U32*)cdict->matchState.chainTable + chainSize); memcpy(cctx->blockState.matchState.hashTable, cdict->matchState.hashTable, tableSpace); /* presumes all tables follow each other */ } /* Zero the hashTable3, since the cdict never fills it */ { size_t const h3Size = (size_t)1 << cctx->blockState.matchState.hashLog3; assert(cdict->matchState.hashLog3 == 0); memset(cctx->blockState.matchState.hashTable3, 0, h3Size * sizeof(U32)); } /* copy dictionary offsets */ { ZSTD_matchState_t const* srcMatchState = &cdict->matchState; ZSTD_matchState_t* dstMatchState = &cctx->blockState.matchState; dstMatchState->window = srcMatchState->window; dstMatchState->nextToUpdate = srcMatchState->nextToUpdate; dstMatchState->nextToUpdate3= srcMatchState->nextToUpdate3; dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd; } cctx->dictID = cdict->dictID; /* copy block state */ memcpy(cctx->blockState.prevCBlock, &cdict->cBlockState, sizeof(cdict->cBlockState)); return 0; } /*! ZSTD_copyCCtx_internal() : * Duplicate an existing context `srcCCtx` into another one `dstCCtx`. * Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()). * The "context", in this case, refers to the hash and chain tables, * entropy tables, and dictionary references. * `windowLog` value is enforced if != 0, otherwise value is copied from srcCCtx. * @return : 0, or an error code */ static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, ZSTD_frameParameters fParams, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff) { DEBUGLOG(5, "ZSTD_copyCCtx_internal"); if (srcCCtx->stage!=ZSTDcs_init) return ERROR(stage_wrong); memcpy(&dstCCtx->customMem, &srcCCtx->customMem, sizeof(ZSTD_customMem)); { ZSTD_CCtx_params params = dstCCtx->requestedParams; /* Copy only compression parameters related to tables. */ params.cParams = srcCCtx->appliedParams.cParams; params.fParams = fParams; ZSTD_resetCCtx_internal(dstCCtx, params, pledgedSrcSize, ZSTDcrp_noMemset, zbuff); assert(dstCCtx->appliedParams.cParams.windowLog == srcCCtx->appliedParams.cParams.windowLog); assert(dstCCtx->appliedParams.cParams.strategy == srcCCtx->appliedParams.cParams.strategy); assert(dstCCtx->appliedParams.cParams.hashLog == srcCCtx->appliedParams.cParams.hashLog); assert(dstCCtx->appliedParams.cParams.chainLog == srcCCtx->appliedParams.cParams.chainLog); assert(dstCCtx->blockState.matchState.hashLog3 == srcCCtx->blockState.matchState.hashLog3); } /* copy tables */ { size_t const chainSize = (srcCCtx->appliedParams.cParams.strategy == ZSTD_fast) ? 0 : ((size_t)1 << srcCCtx->appliedParams.cParams.chainLog); size_t const hSize = (size_t)1 << srcCCtx->appliedParams.cParams.hashLog; size_t const h3Size = (size_t)1 << srcCCtx->blockState.matchState.hashLog3; size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32); assert((U32*)dstCCtx->blockState.matchState.chainTable == (U32*)dstCCtx->blockState.matchState.hashTable + hSize); /* chainTable must follow hashTable */ assert((U32*)dstCCtx->blockState.matchState.hashTable3 == (U32*)dstCCtx->blockState.matchState.chainTable + chainSize); memcpy(dstCCtx->blockState.matchState.hashTable, srcCCtx->blockState.matchState.hashTable, tableSpace); /* presumes all tables follow each other */ } /* copy dictionary offsets */ { ZSTD_matchState_t const* srcMatchState = &srcCCtx->blockState.matchState; ZSTD_matchState_t* dstMatchState = &dstCCtx->blockState.matchState; dstMatchState->window = srcMatchState->window; dstMatchState->nextToUpdate = srcMatchState->nextToUpdate; dstMatchState->nextToUpdate3= srcMatchState->nextToUpdate3; dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd; } dstCCtx->dictID = srcCCtx->dictID; /* copy block state */ memcpy(dstCCtx->blockState.prevCBlock, srcCCtx->blockState.prevCBlock, sizeof(*srcCCtx->blockState.prevCBlock)); return 0; } /*! ZSTD_copyCCtx() : * Duplicate an existing context `srcCCtx` into another one `dstCCtx`. * Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()). * pledgedSrcSize==0 means "unknown". * @return : 0, or an error code */ size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long long pledgedSrcSize) { ZSTD_frameParameters fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ }; ZSTD_buffered_policy_e const zbuff = (ZSTD_buffered_policy_e)(srcCCtx->inBuffSize>0); ZSTD_STATIC_ASSERT((U32)ZSTDb_buffered==1); if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN; fParams.contentSizeFlag = (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN); return ZSTD_copyCCtx_internal(dstCCtx, srcCCtx, fParams, pledgedSrcSize, zbuff); } #define ZSTD_ROWSIZE 16 /*! ZSTD_reduceTable() : * reduce table indexes by `reducerValue`, or squash to zero. * PreserveMark preserves "unsorted mark" for btlazy2 strategy. * It must be set to a clear 0/1 value, to remove branch during inlining. * Presume table size is a multiple of ZSTD_ROWSIZE * to help auto-vectorization */ FORCE_INLINE_TEMPLATE void ZSTD_reduceTable_internal (U32* const table, U32 const size, U32 const reducerValue, int const preserveMark) { int const nbRows = (int)size / ZSTD_ROWSIZE; int cellNb = 0; int rowNb; assert((size & (ZSTD_ROWSIZE-1)) == 0); /* multiple of ZSTD_ROWSIZE */ assert(size < (1U<<31)); /* can be casted to int */ for (rowNb=0 ; rowNb < nbRows ; rowNb++) { int column; for (column=0; columnblockState.matchState; { U32 const hSize = (U32)1 << zc->appliedParams.cParams.hashLog; ZSTD_reduceTable(ms->hashTable, hSize, reducerValue); } if (zc->appliedParams.cParams.strategy != ZSTD_fast) { U32 const chainSize = (U32)1 << zc->appliedParams.cParams.chainLog; if (zc->appliedParams.cParams.strategy == ZSTD_btlazy2) ZSTD_reduceTable_btlazy2(ms->chainTable, chainSize, reducerValue); else ZSTD_reduceTable(ms->chainTable, chainSize, reducerValue); } if (ms->hashLog3) { U32 const h3Size = (U32)1 << ms->hashLog3; ZSTD_reduceTable(ms->hashTable3, h3Size, reducerValue); } } /*-******************************************************* * Block entropic compression *********************************************************/ /* See doc/zstd_compression_format.md for detailed format description */ size_t ZSTD_noCompressBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize) { if (srcSize + ZSTD_blockHeaderSize > dstCapacity) return ERROR(dstSize_tooSmall); memcpy((BYTE*)dst + ZSTD_blockHeaderSize, src, srcSize); MEM_writeLE24(dst, (U32)(srcSize << 2) + (U32)bt_raw); return ZSTD_blockHeaderSize+srcSize; } static size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize) { BYTE* const ostart = (BYTE* const)dst; U32 const flSize = 1 + (srcSize>31) + (srcSize>4095); if (srcSize + flSize > dstCapacity) return ERROR(dstSize_tooSmall); switch(flSize) { case 1: /* 2 - 1 - 5 */ ostart[0] = (BYTE)((U32)set_basic + (srcSize<<3)); break; case 2: /* 2 - 2 - 12 */ MEM_writeLE16(ostart, (U16)((U32)set_basic + (1<<2) + (srcSize<<4))); break; case 3: /* 2 - 2 - 20 */ MEM_writeLE32(ostart, (U32)((U32)set_basic + (3<<2) + (srcSize<<4))); break; default: /* not necessary : flSize is {1,2,3} */ assert(0); } memcpy(ostart + flSize, src, srcSize); return srcSize + flSize; } static size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize) { BYTE* const ostart = (BYTE* const)dst; U32 const flSize = 1 + (srcSize>31) + (srcSize>4095); (void)dstCapacity; /* dstCapacity already guaranteed to be >=4, hence large enough */ switch(flSize) { case 1: /* 2 - 1 - 5 */ ostart[0] = (BYTE)((U32)set_rle + (srcSize<<3)); break; case 2: /* 2 - 2 - 12 */ MEM_writeLE16(ostart, (U16)((U32)set_rle + (1<<2) + (srcSize<<4))); break; case 3: /* 2 - 2 - 20 */ MEM_writeLE32(ostart, (U32)((U32)set_rle + (3<<2) + (srcSize<<4))); break; default: /* not necessary : flSize is {1,2,3} */ assert(0); } ostart[flSize] = *(const BYTE*)src; return flSize+1; } static size_t ZSTD_minGain(size_t srcSize) { return (srcSize >> 6) + 2; } static size_t ZSTD_compressLiterals (ZSTD_entropyCTables_t const* prevEntropy, ZSTD_entropyCTables_t* nextEntropy, ZSTD_strategy strategy, int disableLiteralCompression, void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32* workspace, const int bmi2) { size_t const minGain = ZSTD_minGain(srcSize); size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB); BYTE* const ostart = (BYTE*)dst; U32 singleStream = srcSize < 256; symbolEncodingType_e hType = set_compressed; size_t cLitSize; DEBUGLOG(5,"ZSTD_compressLiterals (disableLiteralCompression=%i)", disableLiteralCompression); /* Prepare nextEntropy assuming reusing the existing table */ nextEntropy->hufCTable_repeatMode = prevEntropy->hufCTable_repeatMode; memcpy(nextEntropy->hufCTable, prevEntropy->hufCTable, sizeof(prevEntropy->hufCTable)); if (disableLiteralCompression) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize); /* small ? don't even attempt compression (speed opt) */ # define COMPRESS_LITERALS_SIZE_MIN 63 { size_t const minLitSize = (prevEntropy->hufCTable_repeatMode == HUF_repeat_valid) ? 6 : COMPRESS_LITERALS_SIZE_MIN; if (srcSize <= minLitSize) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize); } if (dstCapacity < lhSize+1) return ERROR(dstSize_tooSmall); /* not enough space for compression */ { HUF_repeat repeat = prevEntropy->hufCTable_repeatMode; int const preferRepeat = strategy < ZSTD_lazy ? srcSize <= 1024 : 0; if (repeat == HUF_repeat_valid && lhSize == 3) singleStream = 1; cLitSize = singleStream ? HUF_compress1X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11, workspace, HUF_WORKSPACE_SIZE, (HUF_CElt*)nextEntropy->hufCTable, &repeat, preferRepeat, bmi2) : HUF_compress4X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11, workspace, HUF_WORKSPACE_SIZE, (HUF_CElt*)nextEntropy->hufCTable, &repeat, preferRepeat, bmi2); if (repeat != HUF_repeat_none) { /* reused the existing table */ hType = set_repeat; } } if ((cLitSize==0) | (cLitSize >= srcSize - minGain) | ERR_isError(cLitSize)) { memcpy(nextEntropy->hufCTable, prevEntropy->hufCTable, sizeof(prevEntropy->hufCTable)); return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize); } if (cLitSize==1) { memcpy(nextEntropy->hufCTable, prevEntropy->hufCTable, sizeof(prevEntropy->hufCTable)); return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize); } if (hType == set_compressed) { /* using a newly constructed table */ nextEntropy->hufCTable_repeatMode = HUF_repeat_check; } /* Build header */ switch(lhSize) { case 3: /* 2 - 2 - 10 - 10 */ { U32 const lhc = hType + ((!singleStream) << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<14); MEM_writeLE24(ostart, lhc); break; } case 4: /* 2 - 2 - 14 - 14 */ { U32 const lhc = hType + (2 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<18); MEM_writeLE32(ostart, lhc); break; } case 5: /* 2 - 2 - 18 - 18 */ { U32 const lhc = hType + (3 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<22); MEM_writeLE32(ostart, lhc); ostart[4] = (BYTE)(cLitSize >> 10); break; } default: /* not possible : lhSize is {3,4,5} */ assert(0); } return lhSize+cLitSize; } void ZSTD_seqToCodes(const seqStore_t* seqStorePtr) { const seqDef* const sequences = seqStorePtr->sequencesStart; BYTE* const llCodeTable = seqStorePtr->llCode; BYTE* const ofCodeTable = seqStorePtr->ofCode; BYTE* const mlCodeTable = seqStorePtr->mlCode; U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart); U32 u; for (u=0; ulongLengthID==1) llCodeTable[seqStorePtr->longLengthPos] = MaxLL; if (seqStorePtr->longLengthID==2) mlCodeTable[seqStorePtr->longLengthPos] = MaxML; } typedef enum { ZSTD_defaultDisallowed = 0, ZSTD_defaultAllowed = 1 } ZSTD_defaultPolicy_e; MEM_STATIC symbolEncodingType_e ZSTD_selectEncodingType( FSE_repeat* repeatMode, size_t const mostFrequent, size_t nbSeq, U32 defaultNormLog, ZSTD_defaultPolicy_e const isDefaultAllowed) { #define MIN_SEQ_FOR_DYNAMIC_FSE 64 #define MAX_SEQ_FOR_STATIC_FSE 1000 ZSTD_STATIC_ASSERT(ZSTD_defaultDisallowed == 0 && ZSTD_defaultAllowed != 0); if ((mostFrequent == nbSeq) && (!isDefaultAllowed || nbSeq > 2)) { DEBUGLOG(5, "Selected set_rle"); /* Prefer set_basic over set_rle when there are 2 or less symbols, * since RLE uses 1 byte, but set_basic uses 5-6 bits per symbol. * If basic encoding isn't possible, always choose RLE. */ *repeatMode = FSE_repeat_check; return set_rle; } if ( isDefaultAllowed && (*repeatMode == FSE_repeat_valid) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) { DEBUGLOG(5, "Selected set_repeat"); return set_repeat; } if ( isDefaultAllowed && ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (defaultNormLog-1)))) ) { DEBUGLOG(5, "Selected set_basic"); /* The format allows default tables to be repeated, but it isn't useful. * When using simple heuristics to select encoding type, we don't want * to confuse these tables with dictionaries. When running more careful * analysis, we don't need to waste time checking both repeating tables * and default tables. */ *repeatMode = FSE_repeat_none; return set_basic; } DEBUGLOG(5, "Selected set_compressed"); *repeatMode = FSE_repeat_check; return set_compressed; } MEM_STATIC size_t ZSTD_buildCTable(void* dst, size_t dstCapacity, FSE_CTable* nextCTable, U32 FSELog, symbolEncodingType_e type, U32* count, U32 max, BYTE const* codeTable, size_t nbSeq, S16 const* defaultNorm, U32 defaultNormLog, U32 defaultMax, FSE_CTable const* prevCTable, size_t prevCTableSize, void* workspace, size_t workspaceSize) { BYTE* op = (BYTE*)dst; BYTE const* const oend = op + dstCapacity; switch (type) { case set_rle: *op = codeTable[0]; CHECK_F(FSE_buildCTable_rle(nextCTable, (BYTE)max)); return 1; case set_repeat: memcpy(nextCTable, prevCTable, prevCTableSize); return 0; case set_basic: CHECK_F(FSE_buildCTable_wksp(nextCTable, defaultNorm, defaultMax, defaultNormLog, workspace, workspaceSize)); /* note : could be pre-calculated */ return 0; case set_compressed: { S16 norm[MaxSeq + 1]; size_t nbSeq_1 = nbSeq; const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max); if (count[codeTable[nbSeq-1]] > 1) { count[codeTable[nbSeq-1]]--; nbSeq_1--; } assert(nbSeq_1 > 1); CHECK_F(FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max)); { size_t const NCountSize = FSE_writeNCount(op, oend - op, norm, max, tableLog); /* overflow protected */ if (FSE_isError(NCountSize)) return NCountSize; CHECK_F(FSE_buildCTable_wksp(nextCTable, norm, max, tableLog, workspace, workspaceSize)); return NCountSize; } } default: return assert(0), ERROR(GENERIC); } } FORCE_INLINE_TEMPLATE size_t ZSTD_encodeSequences_body( void* dst, size_t dstCapacity, FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable, FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable, FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable, seqDef const* sequences, size_t nbSeq, int longOffsets) { BIT_CStream_t blockStream; FSE_CState_t stateMatchLength; FSE_CState_t stateOffsetBits; FSE_CState_t stateLitLength; CHECK_E(BIT_initCStream(&blockStream, dst, dstCapacity), dstSize_tooSmall); /* not enough space remaining */ /* first symbols */ FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]); FSE_initCState2(&stateOffsetBits, CTable_OffsetBits, ofCodeTable[nbSeq-1]); FSE_initCState2(&stateLitLength, CTable_LitLength, llCodeTable[nbSeq-1]); BIT_addBits(&blockStream, sequences[nbSeq-1].litLength, LL_bits[llCodeTable[nbSeq-1]]); if (MEM_32bits()) BIT_flushBits(&blockStream); BIT_addBits(&blockStream, sequences[nbSeq-1].matchLength, ML_bits[mlCodeTable[nbSeq-1]]); if (MEM_32bits()) BIT_flushBits(&blockStream); if (longOffsets) { U32 const ofBits = ofCodeTable[nbSeq-1]; int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1); if (extraBits) { BIT_addBits(&blockStream, sequences[nbSeq-1].offset, extraBits); BIT_flushBits(&blockStream); } BIT_addBits(&blockStream, sequences[nbSeq-1].offset >> extraBits, ofBits - extraBits); } else { BIT_addBits(&blockStream, sequences[nbSeq-1].offset, ofCodeTable[nbSeq-1]); } BIT_flushBits(&blockStream); { size_t n; for (n=nbSeq-2 ; n= 64-7-(LLFSELog+MLFSELog+OffFSELog))) BIT_flushBits(&blockStream); /* (7)*/ BIT_addBits(&blockStream, sequences[n].litLength, llBits); if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream); BIT_addBits(&blockStream, sequences[n].matchLength, mlBits); if (MEM_32bits() || (ofBits+mlBits+llBits > 56)) BIT_flushBits(&blockStream); if (longOffsets) { int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1); if (extraBits) { BIT_addBits(&blockStream, sequences[n].offset, extraBits); BIT_flushBits(&blockStream); /* (7)*/ } BIT_addBits(&blockStream, sequences[n].offset >> extraBits, ofBits - extraBits); /* 31 */ } else { BIT_addBits(&blockStream, sequences[n].offset, ofBits); /* 31 */ } BIT_flushBits(&blockStream); /* (7)*/ } } DEBUGLOG(6, "ZSTD_encodeSequences: flushing ML state with %u bits", stateMatchLength.stateLog); FSE_flushCState(&blockStream, &stateMatchLength); DEBUGLOG(6, "ZSTD_encodeSequences: flushing Off state with %u bits", stateOffsetBits.stateLog); FSE_flushCState(&blockStream, &stateOffsetBits); DEBUGLOG(6, "ZSTD_encodeSequences: flushing LL state with %u bits", stateLitLength.stateLog); FSE_flushCState(&blockStream, &stateLitLength); { size_t const streamSize = BIT_closeCStream(&blockStream); if (streamSize==0) return ERROR(dstSize_tooSmall); /* not enough space */ return streamSize; } } static size_t ZSTD_encodeSequences_default( void* dst, size_t dstCapacity, FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable, FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable, FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable, seqDef const* sequences, size_t nbSeq, int longOffsets) { return ZSTD_encodeSequences_body(dst, dstCapacity, CTable_MatchLength, mlCodeTable, CTable_OffsetBits, ofCodeTable, CTable_LitLength, llCodeTable, sequences, nbSeq, longOffsets); } #if DYNAMIC_BMI2 static TARGET_ATTRIBUTE("bmi2") size_t ZSTD_encodeSequences_bmi2( void* dst, size_t dstCapacity, FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable, FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable, FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable, seqDef const* sequences, size_t nbSeq, int longOffsets) { return ZSTD_encodeSequences_body(dst, dstCapacity, CTable_MatchLength, mlCodeTable, CTable_OffsetBits, ofCodeTable, CTable_LitLength, llCodeTable, sequences, nbSeq, longOffsets); } #endif size_t ZSTD_encodeSequences( void* dst, size_t dstCapacity, FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable, FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable, FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable, seqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2) { #if DYNAMIC_BMI2 if (bmi2) { return ZSTD_encodeSequences_bmi2(dst, dstCapacity, CTable_MatchLength, mlCodeTable, CTable_OffsetBits, ofCodeTable, CTable_LitLength, llCodeTable, sequences, nbSeq, longOffsets); } #endif (void)bmi2; return ZSTD_encodeSequences_default(dst, dstCapacity, CTable_MatchLength, mlCodeTable, CTable_OffsetBits, ofCodeTable, CTable_LitLength, llCodeTable, sequences, nbSeq, longOffsets); } MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t* seqStorePtr, ZSTD_entropyCTables_t const* prevEntropy, ZSTD_entropyCTables_t* nextEntropy, ZSTD_CCtx_params const* cctxParams, void* dst, size_t dstCapacity, U32* workspace, const int bmi2) { const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN; U32 count[MaxSeq+1]; FSE_CTable* CTable_LitLength = nextEntropy->litlengthCTable; FSE_CTable* CTable_OffsetBits = nextEntropy->offcodeCTable; FSE_CTable* CTable_MatchLength = nextEntropy->matchlengthCTable; U32 LLtype, Offtype, MLtype; /* compressed, raw or rle */ const seqDef* const sequences = seqStorePtr->sequencesStart; const BYTE* const ofCodeTable = seqStorePtr->ofCode; const BYTE* const llCodeTable = seqStorePtr->llCode; const BYTE* const mlCodeTable = seqStorePtr->mlCode; BYTE* const ostart = (BYTE*)dst; BYTE* const oend = ostart + dstCapacity; BYTE* op = ostart; size_t const nbSeq = seqStorePtr->sequences - seqStorePtr->sequencesStart; BYTE* seqHead; ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<litStart; size_t const litSize = seqStorePtr->lit - literals; size_t const cSize = ZSTD_compressLiterals( prevEntropy, nextEntropy, cctxParams->cParams.strategy, cctxParams->disableLiteralCompression, op, dstCapacity, literals, litSize, workspace, bmi2); if (ZSTD_isError(cSize)) return cSize; assert(cSize <= dstCapacity); op += cSize; } /* Sequences Header */ if ((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/) return ERROR(dstSize_tooSmall); if (nbSeq < 0x7F) *op++ = (BYTE)nbSeq; else if (nbSeq < LONGNBSEQ) op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2; else op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3; if (nbSeq==0) { memcpy(nextEntropy->litlengthCTable, prevEntropy->litlengthCTable, sizeof(prevEntropy->litlengthCTable)); nextEntropy->litlength_repeatMode = prevEntropy->litlength_repeatMode; memcpy(nextEntropy->offcodeCTable, prevEntropy->offcodeCTable, sizeof(prevEntropy->offcodeCTable)); nextEntropy->offcode_repeatMode = prevEntropy->offcode_repeatMode; memcpy(nextEntropy->matchlengthCTable, prevEntropy->matchlengthCTable, sizeof(prevEntropy->matchlengthCTable)); nextEntropy->matchlength_repeatMode = prevEntropy->matchlength_repeatMode; return op - ostart; } /* seqHead : flags for FSE encoding type */ seqHead = op++; /* convert length/distances into codes */ ZSTD_seqToCodes(seqStorePtr); /* build CTable for Literal Lengths */ { U32 max = MaxLL; size_t const mostFrequent = FSE_countFast_wksp(count, &max, llCodeTable, nbSeq, workspace); DEBUGLOG(5, "Building LL table"); nextEntropy->litlength_repeatMode = prevEntropy->litlength_repeatMode; LLtype = ZSTD_selectEncodingType(&nextEntropy->litlength_repeatMode, mostFrequent, nbSeq, LL_defaultNormLog, ZSTD_defaultAllowed); { size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype, count, max, llCodeTable, nbSeq, LL_defaultNorm, LL_defaultNormLog, MaxLL, prevEntropy->litlengthCTable, sizeof(prevEntropy->litlengthCTable), workspace, HUF_WORKSPACE_SIZE); if (ZSTD_isError(countSize)) return countSize; op += countSize; } } /* build CTable for Offsets */ { U32 max = MaxOff; size_t const mostFrequent = FSE_countFast_wksp(count, &max, ofCodeTable, nbSeq, workspace); /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */ ZSTD_defaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed; DEBUGLOG(5, "Building OF table"); nextEntropy->offcode_repeatMode = prevEntropy->offcode_repeatMode; Offtype = ZSTD_selectEncodingType(&nextEntropy->offcode_repeatMode, mostFrequent, nbSeq, OF_defaultNormLog, defaultPolicy); { size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype, count, max, ofCodeTable, nbSeq, OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff, prevEntropy->offcodeCTable, sizeof(prevEntropy->offcodeCTable), workspace, HUF_WORKSPACE_SIZE); if (ZSTD_isError(countSize)) return countSize; op += countSize; } } /* build CTable for MatchLengths */ { U32 max = MaxML; size_t const mostFrequent = FSE_countFast_wksp(count, &max, mlCodeTable, nbSeq, workspace); DEBUGLOG(5, "Building ML table"); nextEntropy->matchlength_repeatMode = prevEntropy->matchlength_repeatMode; MLtype = ZSTD_selectEncodingType(&nextEntropy->matchlength_repeatMode, mostFrequent, nbSeq, ML_defaultNormLog, ZSTD_defaultAllowed); { size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype, count, max, mlCodeTable, nbSeq, ML_defaultNorm, ML_defaultNormLog, MaxML, prevEntropy->matchlengthCTable, sizeof(prevEntropy->matchlengthCTable), workspace, HUF_WORKSPACE_SIZE); if (ZSTD_isError(countSize)) return countSize; op += countSize; } } *seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2)); { size_t const bitstreamSize = ZSTD_encodeSequences( op, oend - op, CTable_MatchLength, mlCodeTable, CTable_OffsetBits, ofCodeTable, CTable_LitLength, llCodeTable, sequences, nbSeq, longOffsets, bmi2); if (ZSTD_isError(bitstreamSize)) return bitstreamSize; op += bitstreamSize; } return op - ostart; } MEM_STATIC size_t ZSTD_compressSequences(seqStore_t* seqStorePtr, ZSTD_entropyCTables_t const* prevEntropy, ZSTD_entropyCTables_t* nextEntropy, ZSTD_CCtx_params const* cctxParams, void* dst, size_t dstCapacity, size_t srcSize, U32* workspace, int bmi2) { size_t const cSize = ZSTD_compressSequences_internal( seqStorePtr, prevEntropy, nextEntropy, cctxParams, dst, dstCapacity, workspace, bmi2); /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block. * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block. */ if ((cSize == ERROR(dstSize_tooSmall)) & (srcSize <= dstCapacity)) return 0; /* block not compressed */ if (ZSTD_isError(cSize)) return cSize; /* Check compressibility */ { size_t const maxCSize = srcSize - ZSTD_minGain(srcSize); /* note : fixed formula, maybe should depend on compression level, or strategy */ if (cSize >= maxCSize) return 0; /* block not compressed */ } /* We check that dictionaries have offset codes available for the first * block. After the first block, the offcode table might not have large * enough codes to represent the offsets in the data. */ if (nextEntropy->offcode_repeatMode == FSE_repeat_valid) nextEntropy->offcode_repeatMode = FSE_repeat_check; return cSize; } /* ZSTD_selectBlockCompressor() : * Not static, but internal use only (used by long distance matcher) * assumption : strat is a valid strategy */ ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, int extDict) { static const ZSTD_blockCompressor blockCompressor[2][(unsigned)ZSTD_btultra+1] = { { ZSTD_compressBlock_fast /* default for 0 */, ZSTD_compressBlock_fast, ZSTD_compressBlock_doubleFast, ZSTD_compressBlock_greedy, ZSTD_compressBlock_lazy, ZSTD_compressBlock_lazy2, ZSTD_compressBlock_btlazy2, ZSTD_compressBlock_btopt, ZSTD_compressBlock_btultra }, { ZSTD_compressBlock_fast_extDict /* default for 0 */, ZSTD_compressBlock_fast_extDict, ZSTD_compressBlock_doubleFast_extDict, ZSTD_compressBlock_greedy_extDict, ZSTD_compressBlock_lazy_extDict,ZSTD_compressBlock_lazy2_extDict, ZSTD_compressBlock_btlazy2_extDict, ZSTD_compressBlock_btopt_extDict, ZSTD_compressBlock_btultra_extDict } }; ZSTD_STATIC_ASSERT((unsigned)ZSTD_fast == 1); assert((U32)strat >= (U32)ZSTD_fast); assert((U32)strat <= (U32)ZSTD_btultra); return blockCompressor[extDict!=0][(U32)strat]; } static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr, const BYTE* anchor, size_t lastLLSize) { memcpy(seqStorePtr->lit, anchor, lastLLSize); seqStorePtr->lit += lastLLSize; } static void ZSTD_resetSeqStore(seqStore_t* ssPtr) { ssPtr->lit = ssPtr->litStart; ssPtr->sequences = ssPtr->sequencesStart; ssPtr->longLengthID = 0; } static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc, void* dst, size_t dstCapacity, const void* src, size_t srcSize) { ZSTD_matchState_t* const ms = &zc->blockState.matchState; DEBUGLOG(5, "ZSTD_compressBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)", (U32)dstCapacity, ms->window.dictLimit, ms->nextToUpdate); if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) { ZSTD_ldm_skipSequences(&zc->externSeqStore, srcSize, zc->appliedParams.cParams.searchLength); return 0; /* don't even attempt compression below a certain srcSize */ } ZSTD_resetSeqStore(&(zc->seqStore)); /* limited update after a very long match */ { const BYTE* const base = ms->window.base; const BYTE* const istart = (const BYTE*)src; const U32 current = (U32)(istart-base); if (current > ms->nextToUpdate + 384) ms->nextToUpdate = current - MIN(192, (U32)(current - ms->nextToUpdate - 384)); } /* select and store sequences */ { U32 const extDict = ZSTD_window_hasExtDict(ms->window); size_t lastLLSize; { int i; for (i = 0; i < ZSTD_REP_NUM; ++i) zc->blockState.nextCBlock->rep[i] = zc->blockState.prevCBlock->rep[i]; } if (zc->externSeqStore.pos < zc->externSeqStore.size) { assert(!zc->appliedParams.ldmParams.enableLdm); /* Updates ldmSeqStore.pos */ lastLLSize = ZSTD_ldm_blockCompress(&zc->externSeqStore, ms, &zc->seqStore, zc->blockState.nextCBlock->rep, &zc->appliedParams.cParams, src, srcSize, extDict); assert(zc->externSeqStore.pos <= zc->externSeqStore.size); } else if (zc->appliedParams.ldmParams.enableLdm) { rawSeqStore_t ldmSeqStore = {NULL, 0, 0, 0}; ldmSeqStore.seq = zc->ldmSequences; ldmSeqStore.capacity = zc->maxNbLdmSequences; /* Updates ldmSeqStore.size */ CHECK_F(ZSTD_ldm_generateSequences(&zc->ldmState, &ldmSeqStore, &zc->appliedParams.ldmParams, src, srcSize)); /* Updates ldmSeqStore.pos */ lastLLSize = ZSTD_ldm_blockCompress(&ldmSeqStore, ms, &zc->seqStore, zc->blockState.nextCBlock->rep, &zc->appliedParams.cParams, src, srcSize, extDict); assert(ldmSeqStore.pos == ldmSeqStore.size); } else { /* not long range mode */ ZSTD_blockCompressor const blockCompressor = ZSTD_selectBlockCompressor(zc->appliedParams.cParams.strategy, extDict); lastLLSize = blockCompressor(ms, &zc->seqStore, zc->blockState.nextCBlock->rep, &zc->appliedParams.cParams, src, srcSize); } { const BYTE* const lastLiterals = (const BYTE*)src + srcSize - lastLLSize; ZSTD_storeLastLiterals(&zc->seqStore, lastLiterals, lastLLSize); } } /* encode sequences and literals */ { size_t const cSize = ZSTD_compressSequences(&zc->seqStore, &zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy, &zc->appliedParams, dst, dstCapacity, srcSize, zc->entropyWorkspace, zc->bmi2); if (ZSTD_isError(cSize) || cSize == 0) return cSize; /* confirm repcodes and entropy tables */ { ZSTD_compressedBlockState_t* const tmp = zc->blockState.prevCBlock; zc->blockState.prevCBlock = zc->blockState.nextCBlock; zc->blockState.nextCBlock = tmp; } return cSize; } } /*! ZSTD_compress_frameChunk() : * Compress a chunk of data into one or multiple blocks. * All blocks will be terminated, all input will be consumed. * Function will issue an error if there is not enough `dstCapacity` to hold the compressed content. * Frame is supposed already started (header already produced) * @return : compressed size, or an error code */ static size_t ZSTD_compress_frameChunk (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 lastFrameChunk) { size_t blockSize = cctx->blockSize; size_t remaining = srcSize; const BYTE* ip = (const BYTE*)src; BYTE* const ostart = (BYTE*)dst; BYTE* op = ostart; U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog; assert(cctx->appliedParams.cParams.windowLog <= 31); DEBUGLOG(5, "ZSTD_compress_frameChunk (blockSize=%u)", (U32)blockSize); if (cctx->appliedParams.fParams.checksumFlag && srcSize) XXH64_update(&cctx->xxhState, src, srcSize); while (remaining) { ZSTD_matchState_t* const ms = &cctx->blockState.matchState; U32 const lastBlock = lastFrameChunk & (blockSize >= remaining); if (dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE) return ERROR(dstSize_tooSmall); /* not enough space to store compressed block */ if (remaining < blockSize) blockSize = remaining; if (ZSTD_window_needOverflowCorrection(ms->window, ip + blockSize)) { U32 const cycleLog = ZSTD_cycleLog(cctx->appliedParams.cParams.chainLog, cctx->appliedParams.cParams.strategy); U32 const correction = ZSTD_window_correctOverflow(&ms->window, cycleLog, maxDist, ip); ZSTD_STATIC_ASSERT(ZSTD_CHAINLOG_MAX <= 30); ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX_32 <= 30); ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX <= 31); ZSTD_reduceIndex(cctx, correction); if (ms->nextToUpdate < correction) ms->nextToUpdate = 0; else ms->nextToUpdate -= correction; ms->loadedDictEnd = 0; } ZSTD_window_enforceMaxDist(&ms->window, ip + blockSize, maxDist, &ms->loadedDictEnd); if (ms->nextToUpdate < ms->window.lowLimit) ms->nextToUpdate = ms->window.lowLimit; { size_t cSize = ZSTD_compressBlock_internal(cctx, op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize, ip, blockSize); if (ZSTD_isError(cSize)) return cSize; if (cSize == 0) { /* block is not compressible */ U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(blockSize << 3); if (blockSize + ZSTD_blockHeaderSize > dstCapacity) return ERROR(dstSize_tooSmall); MEM_writeLE32(op, cBlockHeader24); /* 4th byte will be overwritten */ memcpy(op + ZSTD_blockHeaderSize, ip, blockSize); cSize = ZSTD_blockHeaderSize + blockSize; } else { U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3); MEM_writeLE24(op, cBlockHeader24); cSize += ZSTD_blockHeaderSize; } ip += blockSize; assert(remaining >= blockSize); remaining -= blockSize; op += cSize; assert(dstCapacity >= cSize); dstCapacity -= cSize; DEBUGLOG(5, "ZSTD_compress_frameChunk: adding a block of size %u", (U32)cSize); } } if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending; return op-ostart; } static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity, ZSTD_CCtx_params params, U64 pledgedSrcSize, U32 dictID) { BYTE* const op = (BYTE*)dst; U32 const dictIDSizeCodeLength = (dictID>0) + (dictID>=256) + (dictID>=65536); /* 0-3 */ U32 const dictIDSizeCode = params.fParams.noDictIDFlag ? 0 : dictIDSizeCodeLength; /* 0-3 */ U32 const checksumFlag = params.fParams.checksumFlag>0; U32 const windowSize = (U32)1 << params.cParams.windowLog; U32 const singleSegment = params.fParams.contentSizeFlag && (windowSize >= pledgedSrcSize); BYTE const windowLogByte = (BYTE)((params.cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN) << 3); U32 const fcsCode = params.fParams.contentSizeFlag ? (pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) + (pledgedSrcSize>=0xFFFFFFFFU) : 0; /* 0-3 */ BYTE const frameHeaderDecriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) ); size_t pos=0; if (dstCapacity < ZSTD_frameHeaderSize_max) return ERROR(dstSize_tooSmall); DEBUGLOG(4, "ZSTD_writeFrameHeader : dictIDFlag : %u ; dictID : %u ; dictIDSizeCode : %u", !params.fParams.noDictIDFlag, dictID, dictIDSizeCode); if (params.format == ZSTD_f_zstd1) { MEM_writeLE32(dst, ZSTD_MAGICNUMBER); pos = 4; } op[pos++] = frameHeaderDecriptionByte; if (!singleSegment) op[pos++] = windowLogByte; switch(dictIDSizeCode) { default: assert(0); /* impossible */ case 0 : break; case 1 : op[pos] = (BYTE)(dictID); pos++; break; case 2 : MEM_writeLE16(op+pos, (U16)dictID); pos+=2; break; case 3 : MEM_writeLE32(op+pos, dictID); pos+=4; break; } switch(fcsCode) { default: assert(0); /* impossible */ case 0 : if (singleSegment) op[pos++] = (BYTE)(pledgedSrcSize); break; case 1 : MEM_writeLE16(op+pos, (U16)(pledgedSrcSize-256)); pos+=2; break; case 2 : MEM_writeLE32(op+pos, (U32)(pledgedSrcSize)); pos+=4; break; case 3 : MEM_writeLE64(op+pos, (U64)(pledgedSrcSize)); pos+=8; break; } return pos; } /* ZSTD_writeLastEmptyBlock() : * output an empty Block with end-of-frame mark to complete a frame * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h)) * or an error code if `dstCapcity` is too small (stage != ZSTDcs_init) return ERROR(stage_wrong); if (cctx->appliedParams.ldmParams.enableLdm) return ERROR(parameter_unsupported); cctx->externSeqStore.seq = seq; cctx->externSeqStore.size = nbSeq; cctx->externSeqStore.capacity = nbSeq; cctx->externSeqStore.pos = 0; return 0; } static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 frame, U32 lastFrameChunk) { ZSTD_matchState_t* ms = &cctx->blockState.matchState; size_t fhSize = 0; DEBUGLOG(5, "ZSTD_compressContinue_internal, stage: %u, srcSize: %u", cctx->stage, (U32)srcSize); if (cctx->stage==ZSTDcs_created) return ERROR(stage_wrong); /* missing init (ZSTD_compressBegin) */ if (frame && (cctx->stage==ZSTDcs_init)) { fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, cctx->appliedParams, cctx->pledgedSrcSizePlusOne-1, cctx->dictID); if (ZSTD_isError(fhSize)) return fhSize; dstCapacity -= fhSize; dst = (char*)dst + fhSize; cctx->stage = ZSTDcs_ongoing; } if (!srcSize) return fhSize; /* do not generate an empty block if no input */ if (!ZSTD_window_update(&ms->window, src, srcSize)) { ms->nextToUpdate = ms->window.dictLimit; } if (cctx->appliedParams.ldmParams.enableLdm) ZSTD_window_update(&cctx->ldmState.window, src, srcSize); DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (U32)cctx->blockSize); { size_t const cSize = frame ? ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) : ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize); if (ZSTD_isError(cSize)) return cSize; cctx->consumedSrcSize += srcSize; cctx->producedCSize += (cSize + fhSize); if (cctx->appliedParams.fParams.contentSizeFlag) { /* control src size */ if (cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne) { DEBUGLOG(4, "error : pledgedSrcSize = %u, while realSrcSize >= %u", (U32)cctx->pledgedSrcSizePlusOne-1, (U32)cctx->consumedSrcSize); return ERROR(srcSize_wrong); } } return cSize + fhSize; } } size_t ZSTD_compressContinue (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) { DEBUGLOG(5, "ZSTD_compressContinue (srcSize=%u)", (U32)srcSize); return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */); } size_t ZSTD_getBlockSize(const ZSTD_CCtx* cctx) { ZSTD_compressionParameters const cParams = cctx->appliedParams.cParams; assert(!ZSTD_checkCParams(cParams)); return MIN (ZSTD_BLOCKSIZE_MAX, (U32)1 << cParams.windowLog); } size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) { size_t const blockSizeMax = ZSTD_getBlockSize(cctx); if (srcSize > blockSizeMax) return ERROR(srcSize_wrong); return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode */, 0 /* last chunk */); } /*! ZSTD_loadDictionaryContent() : * @return : 0, or an error code */ static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms, ZSTD_CCtx_params const* params, const void* src, size_t srcSize) { const BYTE* const ip = (const BYTE*) src; const BYTE* const iend = ip + srcSize; ZSTD_compressionParameters const* cParams = ¶ms->cParams; ZSTD_window_update(&ms->window, src, srcSize); ms->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ms->window.base); if (srcSize <= HASH_READ_SIZE) return 0; switch(params->cParams.strategy) { case ZSTD_fast: ZSTD_fillHashTable(ms, cParams, iend); break; case ZSTD_dfast: ZSTD_fillDoubleHashTable(ms, cParams, iend); break; case ZSTD_greedy: case ZSTD_lazy: case ZSTD_lazy2: if (srcSize >= HASH_READ_SIZE) ZSTD_insertAndFindFirstIndex(ms, cParams, iend-HASH_READ_SIZE); break; case ZSTD_btlazy2: /* we want the dictionary table fully sorted */ case ZSTD_btopt: case ZSTD_btultra: if (srcSize >= HASH_READ_SIZE) ZSTD_updateTree(ms, cParams, iend-HASH_READ_SIZE, iend); break; default: assert(0); /* not possible : not a valid strategy id */ } ms->nextToUpdate = (U32)(iend - ms->window.base); return 0; } /* Dictionaries that assign zero probability to symbols that show up causes problems when FSE encoding. Refuse dictionaries that assign zero probability to symbols that we may encounter during compression. NOTE: This behavior is not standard and could be improved in the future. */ static size_t ZSTD_checkDictNCount(short* normalizedCounter, unsigned dictMaxSymbolValue, unsigned maxSymbolValue) { U32 s; if (dictMaxSymbolValue < maxSymbolValue) return ERROR(dictionary_corrupted); for (s = 0; s <= maxSymbolValue; ++s) { if (normalizedCounter[s] == 0) return ERROR(dictionary_corrupted); } return 0; } /* Dictionary format : * See : * https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#dictionary-format */ /*! ZSTD_loadZstdDictionary() : * @return : dictID, or an error code * assumptions : magic number supposed already checked * dictSize supposed > 8 */ static size_t ZSTD_loadZstdDictionary(ZSTD_compressedBlockState_t* bs, ZSTD_matchState_t* ms, ZSTD_CCtx_params const* params, const void* dict, size_t dictSize, void* workspace) { const BYTE* dictPtr = (const BYTE*)dict; const BYTE* const dictEnd = dictPtr + dictSize; short offcodeNCount[MaxOff+1]; unsigned offcodeMaxValue = MaxOff; size_t dictID; ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<fParams.noDictIDFlag ? 0 : MEM_readLE32(dictPtr); dictPtr += 4; { unsigned maxSymbolValue = 255; size_t const hufHeaderSize = HUF_readCTable((HUF_CElt*)bs->entropy.hufCTable, &maxSymbolValue, dictPtr, dictEnd-dictPtr); if (HUF_isError(hufHeaderSize)) return ERROR(dictionary_corrupted); if (maxSymbolValue < 255) return ERROR(dictionary_corrupted); dictPtr += hufHeaderSize; } { unsigned offcodeLog; size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr); if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted); if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted); /* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */ CHECK_E( FSE_buildCTable_wksp(bs->entropy.offcodeCTable, offcodeNCount, offcodeMaxValue, offcodeLog, workspace, HUF_WORKSPACE_SIZE), dictionary_corrupted); dictPtr += offcodeHeaderSize; } { short matchlengthNCount[MaxML+1]; unsigned matchlengthMaxValue = MaxML, matchlengthLog; size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr); if (FSE_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted); if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted); /* Every match length code must have non-zero probability */ CHECK_F( ZSTD_checkDictNCount(matchlengthNCount, matchlengthMaxValue, MaxML)); CHECK_E( FSE_buildCTable_wksp(bs->entropy.matchlengthCTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog, workspace, HUF_WORKSPACE_SIZE), dictionary_corrupted); dictPtr += matchlengthHeaderSize; } { short litlengthNCount[MaxLL+1]; unsigned litlengthMaxValue = MaxLL, litlengthLog; size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr); if (FSE_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted); if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted); /* Every literal length code must have non-zero probability */ CHECK_F( ZSTD_checkDictNCount(litlengthNCount, litlengthMaxValue, MaxLL)); CHECK_E( FSE_buildCTable_wksp(bs->entropy.litlengthCTable, litlengthNCount, litlengthMaxValue, litlengthLog, workspace, HUF_WORKSPACE_SIZE), dictionary_corrupted); dictPtr += litlengthHeaderSize; } if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted); bs->rep[0] = MEM_readLE32(dictPtr+0); bs->rep[1] = MEM_readLE32(dictPtr+4); bs->rep[2] = MEM_readLE32(dictPtr+8); dictPtr += 12; { size_t const dictContentSize = (size_t)(dictEnd - dictPtr); U32 offcodeMax = MaxOff; if (dictContentSize <= ((U32)-1) - 128 KB) { U32 const maxOffset = (U32)dictContentSize + 128 KB; /* The maximum offset that must be supported */ offcodeMax = ZSTD_highbit32(maxOffset); /* Calculate minimum offset code required to represent maxOffset */ } /* All offset values <= dictContentSize + 128 KB must be representable */ CHECK_F (ZSTD_checkDictNCount(offcodeNCount, offcodeMaxValue, MIN(offcodeMax, MaxOff))); /* All repCodes must be <= dictContentSize and != 0*/ { U32 u; for (u=0; u<3; u++) { if (bs->rep[u] == 0) return ERROR(dictionary_corrupted); if (bs->rep[u] > dictContentSize) return ERROR(dictionary_corrupted); } } bs->entropy.hufCTable_repeatMode = HUF_repeat_valid; bs->entropy.offcode_repeatMode = FSE_repeat_valid; bs->entropy.matchlength_repeatMode = FSE_repeat_valid; bs->entropy.litlength_repeatMode = FSE_repeat_valid; CHECK_F(ZSTD_loadDictionaryContent(ms, params, dictPtr, dictContentSize)); return dictID; } } /** ZSTD_compress_insertDictionary() : * @return : dictID, or an error code */ static size_t ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs, ZSTD_matchState_t* ms, ZSTD_CCtx_params const* params, const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, void* workspace) { DEBUGLOG(4, "ZSTD_compress_insertDictionary (dictSize=%u)", (U32)dictSize); if ((dict==NULL) || (dictSize<=8)) return 0; ZSTD_reset_compressedBlockState(bs); /* dict restricted modes */ if (dictContentType == ZSTD_dct_rawContent) return ZSTD_loadDictionaryContent(ms, params, dict, dictSize); if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) { if (dictContentType == ZSTD_dct_auto) { DEBUGLOG(4, "raw content dictionary detected"); return ZSTD_loadDictionaryContent(ms, params, dict, dictSize); } if (dictContentType == ZSTD_dct_fullDict) return ERROR(dictionary_wrong); assert(0); /* impossible */ } /* dict as full zstd dictionary */ return ZSTD_loadZstdDictionary(bs, ms, params, dict, dictSize, workspace); } /*! ZSTD_compressBegin_internal() : * @return : 0, or an error code */ size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, const ZSTD_CDict* cdict, ZSTD_CCtx_params params, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff) { DEBUGLOG(4, "ZSTD_compressBegin_internal: wlog=%u", params.cParams.windowLog); /* params are supposed to be fully validated at this point */ assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams))); assert(!((dict) && (cdict))); /* either dict or cdict, not both */ if (cdict && cdict->dictContentSize>0) { cctx->requestedParams = params; return ZSTD_resetCCtx_usingCDict(cctx, cdict, params.cParams.windowLog, params.fParams, pledgedSrcSize, zbuff); } CHECK_F( ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize, ZSTDcrp_continue, zbuff) ); { size_t const dictID = ZSTD_compress_insertDictionary( cctx->blockState.prevCBlock, &cctx->blockState.matchState, ¶ms, dict, dictSize, dictContentType, cctx->entropyWorkspace); if (ZSTD_isError(dictID)) return dictID; assert(dictID <= (size_t)(U32)-1); cctx->dictID = (U32)dictID; } return 0; } size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, const ZSTD_CDict* cdict, ZSTD_CCtx_params params, unsigned long long pledgedSrcSize) { DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal: wlog=%u", params.cParams.windowLog); /* compression parameters verification and optimization */ CHECK_F( ZSTD_checkCParams(params.cParams) ); return ZSTD_compressBegin_internal(cctx, dict, dictSize, dictContentType, cdict, params, pledgedSrcSize, ZSTDb_not_buffered); } /*! ZSTD_compressBegin_advanced() : * @return : 0, or an error code */ size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize) { ZSTD_CCtx_params const cctxParams = ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params); return ZSTD_compressBegin_advanced_internal(cctx, dict, dictSize, ZSTD_dct_auto, NULL /*cdict*/, cctxParams, pledgedSrcSize); } size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel) { ZSTD_parameters const params = ZSTD_getParams(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize); ZSTD_CCtx_params const cctxParams = ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params); DEBUGLOG(4, "ZSTD_compressBegin_usingDict (dictSize=%u)", (U32)dictSize); return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, NULL, cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered); } size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel) { return ZSTD_compressBegin_usingDict(cctx, NULL, 0, compressionLevel); } /*! ZSTD_writeEpilogue() : * Ends a frame. * @return : nb of bytes written into dst (or an error code) */ static size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity) { BYTE* const ostart = (BYTE*)dst; BYTE* op = ostart; size_t fhSize = 0; DEBUGLOG(4, "ZSTD_writeEpilogue"); if (cctx->stage == ZSTDcs_created) return ERROR(stage_wrong); /* init missing */ /* special case : empty frame */ if (cctx->stage == ZSTDcs_init) { fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, cctx->appliedParams, 0, 0); if (ZSTD_isError(fhSize)) return fhSize; dstCapacity -= fhSize; op += fhSize; cctx->stage = ZSTDcs_ongoing; } if (cctx->stage != ZSTDcs_ending) { /* write one last empty block, make it the "last" block */ U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw)<<1) + 0; if (dstCapacity<4) return ERROR(dstSize_tooSmall); MEM_writeLE32(op, cBlockHeader24); op += ZSTD_blockHeaderSize; dstCapacity -= ZSTD_blockHeaderSize; } if (cctx->appliedParams.fParams.checksumFlag) { U32 const checksum = (U32) XXH64_digest(&cctx->xxhState); if (dstCapacity<4) return ERROR(dstSize_tooSmall); DEBUGLOG(4, "ZSTD_writeEpilogue: write checksum : %08X", checksum); MEM_writeLE32(op, checksum); op += 4; } cctx->stage = ZSTDcs_created; /* return to "created but no init" status */ return op-ostart; } size_t ZSTD_compressEnd (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) { size_t endResult; size_t const cSize = ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 1 /* last chunk */); if (ZSTD_isError(cSize)) return cSize; endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize); if (ZSTD_isError(endResult)) return endResult; if (cctx->appliedParams.fParams.contentSizeFlag) { /* control src size */ DEBUGLOG(4, "end of frame : controlling src size"); if (cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1) { DEBUGLOG(4, "error : pledgedSrcSize = %u, while realSrcSize = %u", (U32)cctx->pledgedSrcSizePlusOne-1, (U32)cctx->consumedSrcSize); return ERROR(srcSize_wrong); } } return cSize + endResult; } static size_t ZSTD_compress_internal (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict,size_t dictSize, ZSTD_parameters params) { ZSTD_CCtx_params const cctxParams = ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params); DEBUGLOG(4, "ZSTD_compress_internal"); return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, cctxParams); } size_t ZSTD_compress_advanced (ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict,size_t dictSize, ZSTD_parameters params) { DEBUGLOG(4, "ZSTD_compress_advanced"); CHECK_F(ZSTD_checkCParams(params.cParams)); return ZSTD_compress_internal(ctx, dst, dstCapacity, src, srcSize, dict, dictSize, params); } /* Internal */ size_t ZSTD_compress_advanced_internal( ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict,size_t dictSize, ZSTD_CCtx_params params) { DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (U32)srcSize); CHECK_F( ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, NULL, params, srcSize, ZSTDb_not_buffered) ); return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize); } size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict, size_t dictSize, int compressionLevel) { ZSTD_parameters const params = ZSTD_getParams(compressionLevel, srcSize ? srcSize : 1, dict ? dictSize : 0); ZSTD_CCtx_params cctxParams = ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params); assert(params.fParams.contentSizeFlag == 1); ZSTD_CCtxParam_setParameter(&cctxParams, ZSTD_p_compressLiterals, compressionLevel>=0); return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, cctxParams); } size_t ZSTD_compressCCtx (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel) { DEBUGLOG(4, "ZSTD_compressCCtx (srcSize=%u)", (U32)srcSize); return ZSTD_compress_usingDict(cctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel); } size_t ZSTD_compress(void* dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel) { size_t result; ZSTD_CCtx ctxBody; memset(&ctxBody, 0, sizeof(ctxBody)); ctxBody.customMem = ZSTD_defaultCMem; result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel); ZSTD_free(ctxBody.workSpace, ZSTD_defaultCMem); /* can't free ctxBody itself, as it's on stack; free only heap content */ return result; } /* ===== Dictionary API ===== */ /*! ZSTD_estimateCDictSize_advanced() : * Estimate amount of memory that will be needed to create a dictionary with following arguments */ size_t ZSTD_estimateCDictSize_advanced( size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod) { DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (U32)sizeof(ZSTD_CDict)); return sizeof(ZSTD_CDict) + HUF_WORKSPACE_SIZE + ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize); } size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel) { ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, 0, dictSize); return ZSTD_estimateCDictSize_advanced(dictSize, cParams, ZSTD_dlm_byCopy); } size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict) { if (cdict==NULL) return 0; /* support sizeof on NULL */ DEBUGLOG(5, "sizeof(*cdict) : %u", (U32)sizeof(*cdict)); return cdict->workspaceSize + (cdict->dictBuffer ? cdict->dictContentSize : 0) + sizeof(*cdict); } static size_t ZSTD_initCDict_internal( ZSTD_CDict* cdict, const void* dictBuffer, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_compressionParameters cParams) { DEBUGLOG(3, "ZSTD_initCDict_internal, dictContentType %u", (U32)dictContentType); assert(!ZSTD_checkCParams(cParams)); cdict->cParams = cParams; if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dictBuffer) || (!dictSize)) { cdict->dictBuffer = NULL; cdict->dictContent = dictBuffer; } else { void* const internalBuffer = ZSTD_malloc(dictSize, cdict->customMem); cdict->dictBuffer = internalBuffer; cdict->dictContent = internalBuffer; if (!internalBuffer) return ERROR(memory_allocation); memcpy(internalBuffer, dictBuffer, dictSize); } cdict->dictContentSize = dictSize; /* Reset the state to no dictionary */ ZSTD_reset_compressedBlockState(&cdict->cBlockState); { void* const end = ZSTD_reset_matchState( &cdict->matchState, (U32*)cdict->workspace + HUF_WORKSPACE_SIZE_U32, &cParams, ZSTDcrp_continue, /* forCCtx */ 0); assert(end == (char*)cdict->workspace + cdict->workspaceSize); (void)end; } /* (Maybe) load the dictionary * Skips loading the dictionary if it is <= 8 bytes. */ { ZSTD_CCtx_params params; memset(¶ms, 0, sizeof(params)); params.compressionLevel = ZSTD_CLEVEL_DEFAULT; params.fParams.contentSizeFlag = 1; params.cParams = cParams; { size_t const dictID = ZSTD_compress_insertDictionary( &cdict->cBlockState, &cdict->matchState, ¶ms, cdict->dictContent, cdict->dictContentSize, dictContentType, cdict->workspace); if (ZSTD_isError(dictID)) return dictID; assert(dictID <= (size_t)(U32)-1); cdict->dictID = (U32)dictID; } } return 0; } ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_compressionParameters cParams, ZSTD_customMem customMem) { DEBUGLOG(3, "ZSTD_createCDict_advanced, mode %u", (U32)dictContentType); if (!customMem.customAlloc ^ !customMem.customFree) return NULL; { ZSTD_CDict* const cdict = (ZSTD_CDict*)ZSTD_malloc(sizeof(ZSTD_CDict), customMem); size_t const workspaceSize = HUF_WORKSPACE_SIZE + ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0); void* const workspace = ZSTD_malloc(workspaceSize, customMem); if (!cdict || !workspace) { ZSTD_free(cdict, customMem); ZSTD_free(workspace, customMem); return NULL; } cdict->customMem = customMem; cdict->workspace = workspace; cdict->workspaceSize = workspaceSize; if (ZSTD_isError( ZSTD_initCDict_internal(cdict, dictBuffer, dictSize, dictLoadMethod, dictContentType, cParams) )) { ZSTD_freeCDict(cdict); return NULL; } return cdict; } } ZSTD_CDict* ZSTD_createCDict(const void* dict, size_t dictSize, int compressionLevel) { ZSTD_compressionParameters cParams = ZSTD_getCParams(compressionLevel, 0, dictSize); return ZSTD_createCDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, cParams, ZSTD_defaultCMem); } ZSTD_CDict* ZSTD_createCDict_byReference(const void* dict, size_t dictSize, int compressionLevel) { ZSTD_compressionParameters cParams = ZSTD_getCParams(compressionLevel, 0, dictSize); return ZSTD_createCDict_advanced(dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, cParams, ZSTD_defaultCMem); } size_t ZSTD_freeCDict(ZSTD_CDict* cdict) { if (cdict==NULL) return 0; /* support free on NULL */ { ZSTD_customMem const cMem = cdict->customMem; ZSTD_free(cdict->workspace, cMem); ZSTD_free(cdict->dictBuffer, cMem); ZSTD_free(cdict, cMem); return 0; } } /*! ZSTD_initStaticCDict_advanced() : * Generate a digested dictionary in provided memory area. * workspace: The memory area to emplace the dictionary into. * Provided pointer must 8-bytes aligned. * It must outlive dictionary usage. * workspaceSize: Use ZSTD_estimateCDictSize() * to determine how large workspace must be. * cParams : use ZSTD_getCParams() to transform a compression level * into its relevants cParams. * @return : pointer to ZSTD_CDict*, or NULL if error (size too small) * Note : there is no corresponding "free" function. * Since workspace was allocated externally, it must be freed externally. */ const ZSTD_CDict* ZSTD_initStaticCDict( void* workspace, size_t workspaceSize, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_compressionParameters cParams) { size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0); size_t const neededSize = sizeof(ZSTD_CDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize) + HUF_WORKSPACE_SIZE + matchStateSize; ZSTD_CDict* const cdict = (ZSTD_CDict*) workspace; void* ptr; if ((size_t)workspace & 7) return NULL; /* 8-aligned */ DEBUGLOG(4, "(workspaceSize < neededSize) : (%u < %u) => %u", (U32)workspaceSize, (U32)neededSize, (U32)(workspaceSize < neededSize)); if (workspaceSize < neededSize) return NULL; if (dictLoadMethod == ZSTD_dlm_byCopy) { memcpy(cdict+1, dict, dictSize); dict = cdict+1; ptr = (char*)workspace + sizeof(ZSTD_CDict) + dictSize; } else { ptr = cdict+1; } cdict->workspace = ptr; cdict->workspaceSize = HUF_WORKSPACE_SIZE + matchStateSize; if (ZSTD_isError( ZSTD_initCDict_internal(cdict, dict, dictSize, ZSTD_dlm_byRef, dictContentType, cParams) )) return NULL; return cdict; } ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict) { assert(cdict != NULL); return cdict->cParams; } /* ZSTD_compressBegin_usingCDict_advanced() : * cdict must be != NULL */ size_t ZSTD_compressBegin_usingCDict_advanced( ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize) { DEBUGLOG(4, "ZSTD_compressBegin_usingCDict_advanced"); if (cdict==NULL) return ERROR(dictionary_wrong); { ZSTD_CCtx_params params = cctx->requestedParams; params.cParams = ZSTD_getCParamsFromCDict(cdict); /* Increase window log to fit the entire dictionary and source if the * source size is known. Limit the increase to 19, which is the * window log for compression level 1 with the largest source size. */ if (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN) { U32 const limitedSrcSize = (U32)MIN(pledgedSrcSize, 1U << 19); U32 const limitedSrcLog = limitedSrcSize > 1 ? ZSTD_highbit32(limitedSrcSize - 1) + 1 : 1; params.cParams.windowLog = MAX(params.cParams.windowLog, limitedSrcLog); } params.fParams = fParams; return ZSTD_compressBegin_internal(cctx, NULL, 0, ZSTD_dct_auto, cdict, params, pledgedSrcSize, ZSTDb_not_buffered); } } /* ZSTD_compressBegin_usingCDict() : * pledgedSrcSize=0 means "unknown" * if pledgedSrcSize>0, it will enable contentSizeFlag */ size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict) { ZSTD_frameParameters const fParams = { 0 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ }; DEBUGLOG(4, "ZSTD_compressBegin_usingCDict : dictIDFlag == %u", !fParams.noDictIDFlag); return ZSTD_compressBegin_usingCDict_advanced(cctx, cdict, fParams, 0); } size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams) { CHECK_F (ZSTD_compressBegin_usingCDict_advanced(cctx, cdict, fParams, srcSize)); /* will check if cdict != NULL */ return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize); } /*! ZSTD_compress_usingCDict() : * Compression using a digested Dictionary. * Faster startup than ZSTD_compress_usingDict(), recommended when same dictionary is used multiple times. * Note that compression parameters are decided at CDict creation time * while frame parameters are hardcoded */ size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const ZSTD_CDict* cdict) { ZSTD_frameParameters const fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ }; return ZSTD_compress_usingCDict_advanced(cctx, dst, dstCapacity, src, srcSize, cdict, fParams); } /* ****************************************************************** * Streaming ********************************************************************/ ZSTD_CStream* ZSTD_createCStream(void) { DEBUGLOG(3, "ZSTD_createCStream"); return ZSTD_createCStream_advanced(ZSTD_defaultCMem); } ZSTD_CStream* ZSTD_initStaticCStream(void *workspace, size_t workspaceSize) { return ZSTD_initStaticCCtx(workspace, workspaceSize); } ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem) { /* CStream and CCtx are now same object */ return ZSTD_createCCtx_advanced(customMem); } size_t ZSTD_freeCStream(ZSTD_CStream* zcs) { return ZSTD_freeCCtx(zcs); /* same object */ } /*====== Initialization ======*/ size_t ZSTD_CStreamInSize(void) { return ZSTD_BLOCKSIZE_MAX; } size_t ZSTD_CStreamOutSize(void) { return ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + 4 /* 32-bits hash */ ; } static size_t ZSTD_resetCStream_internal(ZSTD_CStream* cctx, const void* const dict, size_t const dictSize, ZSTD_dictContentType_e const dictContentType, const ZSTD_CDict* const cdict, ZSTD_CCtx_params const params, unsigned long long const pledgedSrcSize) { DEBUGLOG(4, "ZSTD_resetCStream_internal (disableLiteralCompression=%i)", params.disableLiteralCompression); /* params are supposed to be fully validated at this point */ assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams))); assert(!((dict) && (cdict))); /* either dict or cdict, not both */ CHECK_F( ZSTD_compressBegin_internal(cctx, dict, dictSize, dictContentType, cdict, params, pledgedSrcSize, ZSTDb_buffered) ); cctx->inToCompress = 0; cctx->inBuffPos = 0; cctx->inBuffTarget = cctx->blockSize + (cctx->blockSize == pledgedSrcSize); /* for small input: avoid automatic flush on reaching end of block, since it would require to add a 3-bytes null block to end frame */ cctx->outBuffContentSize = cctx->outBuffFlushedSize = 0; cctx->streamStage = zcss_load; cctx->frameEnded = 0; return 0; /* ready to go */ } /* ZSTD_resetCStream(): * pledgedSrcSize == 0 means "unknown" */ size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize) { ZSTD_CCtx_params params = zcs->requestedParams; DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (U32)pledgedSrcSize); if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN; params.fParams.contentSizeFlag = 1; params.cParams = ZSTD_getCParamsFromCCtxParams(¶ms, pledgedSrcSize, 0); return ZSTD_resetCStream_internal(zcs, NULL, 0, ZSTD_dct_auto, zcs->cdict, params, pledgedSrcSize); } /*! ZSTD_initCStream_internal() : * Note : for lib/compress only. Used by zstdmt_compress.c. * Assumption 1 : params are valid * Assumption 2 : either dict, or cdict, is defined, not both */ size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs, const void* dict, size_t dictSize, const ZSTD_CDict* cdict, ZSTD_CCtx_params params, unsigned long long pledgedSrcSize) { DEBUGLOG(4, "ZSTD_initCStream_internal"); assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams))); assert(!((dict) && (cdict))); /* either dict or cdict, not both */ if (dict && dictSize >= 8) { DEBUGLOG(4, "loading dictionary of size %u", (U32)dictSize); if (zcs->staticSize) { /* static CCtx : never uses malloc */ /* incompatible with internal cdict creation */ return ERROR(memory_allocation); } ZSTD_freeCDict(zcs->cdictLocal); zcs->cdictLocal = ZSTD_createCDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, params.cParams, zcs->customMem); zcs->cdict = zcs->cdictLocal; if (zcs->cdictLocal == NULL) return ERROR(memory_allocation); } else { if (cdict) { params.cParams = ZSTD_getCParamsFromCDict(cdict); /* cParams are enforced from cdict; it includes windowLog */ } ZSTD_freeCDict(zcs->cdictLocal); zcs->cdictLocal = NULL; zcs->cdict = cdict; } return ZSTD_resetCStream_internal(zcs, NULL, 0, ZSTD_dct_auto, zcs->cdict, params, pledgedSrcSize); } /* ZSTD_initCStream_usingCDict_advanced() : * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */ size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize) { DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced"); if (!cdict) return ERROR(dictionary_wrong); /* cannot handle NULL cdict (does not know what to do) */ { ZSTD_CCtx_params params = zcs->requestedParams; params.cParams = ZSTD_getCParamsFromCDict(cdict); params.fParams = fParams; return ZSTD_initCStream_internal(zcs, NULL, 0, cdict, params, pledgedSrcSize); } } /* note : cdict must outlive compression session */ size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict) { ZSTD_frameParameters const fParams = { 0 /* contentSizeFlag */, 0 /* checksum */, 0 /* hideDictID */ }; DEBUGLOG(4, "ZSTD_initCStream_usingCDict"); return ZSTD_initCStream_usingCDict_advanced(zcs, cdict, fParams, ZSTD_CONTENTSIZE_UNKNOWN); /* note : will check that cdict != NULL */ } /* ZSTD_initCStream_advanced() : * pledgedSrcSize must be exact. * if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. * dict is loaded with default parameters ZSTD_dm_auto and ZSTD_dlm_byCopy. */ size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize) { DEBUGLOG(4, "ZSTD_initCStream_advanced: pledgedSrcSize=%u, flag=%u", (U32)pledgedSrcSize, params.fParams.contentSizeFlag); CHECK_F( ZSTD_checkCParams(params.cParams) ); if ((pledgedSrcSize==0) && (params.fParams.contentSizeFlag==0)) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN; /* for compatibility with older programs relying on this behavior. Users should now specify ZSTD_CONTENTSIZE_UNKNOWN. This line will be removed in the future. */ { ZSTD_CCtx_params const cctxParams = ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params); return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL /*cdict*/, cctxParams, pledgedSrcSize); } } size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel) { ZSTD_parameters const params = ZSTD_getParams(compressionLevel, 0, dictSize); ZSTD_CCtx_params const cctxParams = ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params); return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL, cctxParams, ZSTD_CONTENTSIZE_UNKNOWN); } size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss) { U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss; /* temporary : 0 interpreted as "unknown" during transition period. Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN. `0` will be interpreted as "empty" in the future */ ZSTD_parameters const params = ZSTD_getParams(compressionLevel, pledgedSrcSize, 0); ZSTD_CCtx_params const cctxParams = ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params); return ZSTD_initCStream_internal(zcs, NULL, 0, NULL, cctxParams, pledgedSrcSize); } size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel) { DEBUGLOG(4, "ZSTD_initCStream"); return ZSTD_initCStream_srcSize(zcs, compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN); } /*====== Compression ======*/ MEM_STATIC size_t ZSTD_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize) { size_t const length = MIN(dstCapacity, srcSize); if (length) memcpy(dst, src, length); return length; } /** ZSTD_compressStream_generic(): * internal function for all *compressStream*() variants and *compress_generic() * non-static, because can be called from zstdmt_compress.c * @return : hint size for next input */ size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input, ZSTD_EndDirective const flushMode) { const char* const istart = (const char*)input->src; const char* const iend = istart + input->size; const char* ip = istart + input->pos; char* const ostart = (char*)output->dst; char* const oend = ostart + output->size; char* op = ostart + output->pos; U32 someMoreWork = 1; /* check expectations */ DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (U32)flushMode); assert(zcs->inBuff != NULL); assert(zcs->inBuffSize > 0); assert(zcs->outBuff != NULL); assert(zcs->outBuffSize > 0); assert(output->pos <= output->size); assert(input->pos <= input->size); while (someMoreWork) { switch(zcs->streamStage) { case zcss_init: /* call ZSTD_initCStream() first ! */ return ERROR(init_missing); case zcss_load: if ( (flushMode == ZSTD_e_end) && ((size_t)(oend-op) >= ZSTD_compressBound(iend-ip)) /* enough dstCapacity */ && (zcs->inBuffPos == 0) ) { /* shortcut to compression pass directly into output buffer */ size_t const cSize = ZSTD_compressEnd(zcs, op, oend-op, ip, iend-ip); DEBUGLOG(4, "ZSTD_compressEnd : %u", (U32)cSize); if (ZSTD_isError(cSize)) return cSize; ip = iend; op += cSize; zcs->frameEnded = 1; ZSTD_startNewCompression(zcs); someMoreWork = 0; break; } /* complete loading into inBuffer */ { size_t const toLoad = zcs->inBuffTarget - zcs->inBuffPos; size_t const loaded = ZSTD_limitCopy( zcs->inBuff + zcs->inBuffPos, toLoad, ip, iend-ip); zcs->inBuffPos += loaded; ip += loaded; if ( (flushMode == ZSTD_e_continue) && (zcs->inBuffPos < zcs->inBuffTarget) ) { /* not enough input to fill full block : stop here */ someMoreWork = 0; break; } if ( (flushMode == ZSTD_e_flush) && (zcs->inBuffPos == zcs->inToCompress) ) { /* empty */ someMoreWork = 0; break; } } /* compress current block (note : this stage cannot be stopped in the middle) */ DEBUGLOG(5, "stream compression stage (flushMode==%u)", flushMode); { void* cDst; size_t cSize; size_t const iSize = zcs->inBuffPos - zcs->inToCompress; size_t oSize = oend-op; unsigned const lastBlock = (flushMode == ZSTD_e_end) && (ip==iend); if (oSize >= ZSTD_compressBound(iSize)) cDst = op; /* compress into output buffer, to skip flush stage */ else cDst = zcs->outBuff, oSize = zcs->outBuffSize; cSize = lastBlock ? ZSTD_compressEnd(zcs, cDst, oSize, zcs->inBuff + zcs->inToCompress, iSize) : ZSTD_compressContinue(zcs, cDst, oSize, zcs->inBuff + zcs->inToCompress, iSize); if (ZSTD_isError(cSize)) return cSize; zcs->frameEnded = lastBlock; /* prepare next block */ zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSize; if (zcs->inBuffTarget > zcs->inBuffSize) zcs->inBuffPos = 0, zcs->inBuffTarget = zcs->blockSize; DEBUGLOG(5, "inBuffTarget:%u / inBuffSize:%u", (U32)zcs->inBuffTarget, (U32)zcs->inBuffSize); if (!lastBlock) assert(zcs->inBuffTarget <= zcs->inBuffSize); zcs->inToCompress = zcs->inBuffPos; if (cDst == op) { /* no need to flush */ op += cSize; if (zcs->frameEnded) { DEBUGLOG(5, "Frame completed directly in outBuffer"); someMoreWork = 0; ZSTD_startNewCompression(zcs); } break; } zcs->outBuffContentSize = cSize; zcs->outBuffFlushedSize = 0; zcs->streamStage = zcss_flush; /* pass-through to flush stage */ } /* fall-through */ case zcss_flush: DEBUGLOG(5, "flush stage"); { size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize; size_t const flushed = ZSTD_limitCopy(op, oend-op, zcs->outBuff + zcs->outBuffFlushedSize, toFlush); DEBUGLOG(5, "toFlush: %u into %u ==> flushed: %u", (U32)toFlush, (U32)(oend-op), (U32)flushed); op += flushed; zcs->outBuffFlushedSize += flushed; if (toFlush!=flushed) { /* flush not fully completed, presumably because dst is too small */ assert(op==oend); someMoreWork = 0; break; } zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0; if (zcs->frameEnded) { DEBUGLOG(5, "Frame completed on flush"); someMoreWork = 0; ZSTD_startNewCompression(zcs); break; } zcs->streamStage = zcss_load; break; } default: /* impossible */ assert(0); } } input->pos = ip - istart; output->pos = op - ostart; if (zcs->frameEnded) return 0; { size_t hintInSize = zcs->inBuffTarget - zcs->inBuffPos; if (hintInSize==0) hintInSize = zcs->blockSize; return hintInSize; } } size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input) { /* check conditions */ if (output->pos > output->size) return ERROR(GENERIC); if (input->pos > input->size) return ERROR(GENERIC); return ZSTD_compressStream_generic(zcs, output, input, ZSTD_e_continue); } size_t ZSTD_compress_generic (ZSTD_CCtx* cctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input, ZSTD_EndDirective endOp) { DEBUGLOG(5, "ZSTD_compress_generic, endOp=%u ", (U32)endOp); /* check conditions */ if (output->pos > output->size) return ERROR(GENERIC); if (input->pos > input->size) return ERROR(GENERIC); assert(cctx!=NULL); /* transparent initialization stage */ if (cctx->streamStage == zcss_init) { ZSTD_CCtx_params params = cctx->requestedParams; ZSTD_prefixDict const prefixDict = cctx->prefixDict; memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict)); /* single usage */ assert(prefixDict.dict==NULL || cctx->cdict==NULL); /* only one can be set */ DEBUGLOG(4, "ZSTD_compress_generic : transparent init stage"); if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1; /* auto-fix pledgedSrcSize */ params.cParams = ZSTD_getCParamsFromCCtxParams( &cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, 0 /*dictSize*/); #ifdef ZSTD_MULTITHREAD if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN) { params.nbWorkers = 0; /* do not invoke multi-threading when src size is too small */ } if (params.nbWorkers > 0) { /* mt context creation */ if (cctx->mtctx == NULL || (params.nbWorkers != ZSTDMT_getNbWorkers(cctx->mtctx))) { DEBUGLOG(4, "ZSTD_compress_generic: creating new mtctx for nbWorkers=%u", params.nbWorkers); if (cctx->mtctx != NULL) DEBUGLOG(4, "ZSTD_compress_generic: previous nbWorkers was %u", ZSTDMT_getNbWorkers(cctx->mtctx)); ZSTDMT_freeCCtx(cctx->mtctx); cctx->mtctx = ZSTDMT_createCCtx_advanced(params.nbWorkers, cctx->customMem); if (cctx->mtctx == NULL) return ERROR(memory_allocation); } /* mt compression */ DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers); CHECK_F( ZSTDMT_initCStream_internal( cctx->mtctx, prefixDict.dict, prefixDict.dictSize, ZSTD_dct_rawContent, cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) ); cctx->streamStage = zcss_load; cctx->appliedParams.nbWorkers = params.nbWorkers; } else #endif { CHECK_F( ZSTD_resetCStream_internal(cctx, prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType, cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) ); assert(cctx->streamStage == zcss_load); assert(cctx->appliedParams.nbWorkers == 0); } } /* compression stage */ #ifdef ZSTD_MULTITHREAD if (cctx->appliedParams.nbWorkers > 0) { if (cctx->cParamsChanged) { ZSTDMT_updateCParams_whileCompressing(cctx->mtctx, &cctx->requestedParams); cctx->cParamsChanged = 0; } { size_t const flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp); if ( ZSTD_isError(flushMin) || (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */ ZSTD_startNewCompression(cctx); } return flushMin; } } #endif CHECK_F( ZSTD_compressStream_generic(cctx, output, input, endOp) ); DEBUGLOG(5, "completed ZSTD_compress_generic"); return cctx->outBuffContentSize - cctx->outBuffFlushedSize; /* remaining to flush */ } size_t ZSTD_compress_generic_simpleArgs ( ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, size_t* dstPos, const void* src, size_t srcSize, size_t* srcPos, ZSTD_EndDirective endOp) { ZSTD_outBuffer output = { dst, dstCapacity, *dstPos }; ZSTD_inBuffer input = { src, srcSize, *srcPos }; /* ZSTD_compress_generic() will check validity of dstPos and srcPos */ size_t const cErr = ZSTD_compress_generic(cctx, &output, &input, endOp); *dstPos = output.pos; *srcPos = input.pos; return cErr; } /*====== Finalize ======*/ /*! ZSTD_flushStream() : * @return : amount of data remaining to flush */ size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output) { ZSTD_inBuffer input = { NULL, 0, 0 }; if (output->pos > output->size) return ERROR(GENERIC); CHECK_F( ZSTD_compressStream_generic(zcs, output, &input, ZSTD_e_flush) ); return zcs->outBuffContentSize - zcs->outBuffFlushedSize; /* remaining to flush */ } size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output) { ZSTD_inBuffer input = { NULL, 0, 0 }; if (output->pos > output->size) return ERROR(GENERIC); CHECK_F( ZSTD_compressStream_generic(zcs, output, &input, ZSTD_e_end) ); { size_t const lastBlockSize = zcs->frameEnded ? 0 : ZSTD_BLOCKHEADERSIZE; size_t const checksumSize = zcs->frameEnded ? 0 : zcs->appliedParams.fParams.checksumFlag * 4; size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize + lastBlockSize + checksumSize; DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (U32)toFlush); return toFlush; } } /*-===== Pre-defined compression levels =====-*/ #define ZSTD_MAX_CLEVEL 22 int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; } static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL+1] = { { /* "default" - guarantees a monotonically increasing memory budget */ /* W, C, H, S, L, TL, strat */ { 19, 12, 13, 1, 6, 1, ZSTD_fast }, /* base for negative levels */ { 19, 13, 14, 1, 7, 1, ZSTD_fast }, /* level 1 */ { 19, 15, 16, 1, 6, 1, ZSTD_fast }, /* level 2 */ { 20, 16, 17, 1, 5, 8, ZSTD_dfast }, /* level 3 */ { 20, 17, 18, 1, 5, 8, ZSTD_dfast }, /* level 4 */ { 20, 17, 18, 2, 5, 16, ZSTD_greedy }, /* level 5 */ { 21, 17, 19, 2, 5, 16, ZSTD_lazy }, /* level 6 */ { 21, 18, 19, 3, 5, 16, ZSTD_lazy }, /* level 7 */ { 21, 18, 20, 3, 5, 16, ZSTD_lazy2 }, /* level 8 */ { 21, 19, 20, 3, 5, 16, ZSTD_lazy2 }, /* level 9 */ { 21, 19, 21, 4, 5, 16, ZSTD_lazy2 }, /* level 10 */ { 22, 20, 22, 4, 5, 16, ZSTD_lazy2 }, /* level 11 */ { 22, 20, 22, 5, 5, 16, ZSTD_lazy2 }, /* level 12 */ { 22, 21, 22, 4, 5, 32, ZSTD_btlazy2 }, /* level 13 */ { 22, 21, 22, 5, 5, 32, ZSTD_btlazy2 }, /* level 14 */ { 22, 22, 22, 6, 5, 32, ZSTD_btlazy2 }, /* level 15 */ { 22, 21, 22, 4, 5, 48, ZSTD_btopt }, /* level 16 */ { 23, 22, 22, 4, 4, 48, ZSTD_btopt }, /* level 17 */ { 23, 22, 22, 5, 3, 64, ZSTD_btopt }, /* level 18 */ { 23, 23, 22, 7, 3,128, ZSTD_btopt }, /* level 19 */ { 25, 25, 23, 7, 3,128, ZSTD_btultra }, /* level 20 */ { 26, 26, 24, 7, 3,256, ZSTD_btultra }, /* level 21 */ { 27, 27, 25, 9, 3,512, ZSTD_btultra }, /* level 22 */ }, { /* for srcSize <= 256 KB */ /* W, C, H, S, L, T, strat */ { 18, 12, 13, 1, 5, 1, ZSTD_fast }, /* base for negative levels */ { 18, 13, 14, 1, 6, 1, ZSTD_fast }, /* level 1 */ { 18, 14, 13, 1, 5, 8, ZSTD_dfast }, /* level 2 */ { 18, 16, 15, 1, 5, 8, ZSTD_dfast }, /* level 3 */ { 18, 15, 17, 1, 5, 8, ZSTD_greedy }, /* level 4.*/ { 18, 16, 17, 4, 5, 8, ZSTD_greedy }, /* level 5.*/ { 18, 16, 17, 3, 5, 8, ZSTD_lazy }, /* level 6.*/ { 18, 17, 17, 4, 4, 8, ZSTD_lazy }, /* level 7 */ { 18, 17, 17, 4, 4, 8, ZSTD_lazy2 }, /* level 8 */ { 18, 17, 17, 5, 4, 8, ZSTD_lazy2 }, /* level 9 */ { 18, 17, 17, 6, 4, 8, ZSTD_lazy2 }, /* level 10 */ { 18, 18, 17, 6, 4, 8, ZSTD_lazy2 }, /* level 11.*/ { 18, 18, 17, 5, 4, 8, ZSTD_btlazy2 }, /* level 12.*/ { 18, 19, 17, 7, 4, 8, ZSTD_btlazy2 }, /* level 13 */ { 18, 18, 18, 4, 4, 16, ZSTD_btopt }, /* level 14.*/ { 18, 18, 18, 4, 3, 16, ZSTD_btopt }, /* level 15.*/ { 18, 19, 18, 6, 3, 32, ZSTD_btopt }, /* level 16.*/ { 18, 19, 18, 8, 3, 64, ZSTD_btopt }, /* level 17.*/ { 18, 19, 18, 9, 3,128, ZSTD_btopt }, /* level 18.*/ { 18, 19, 18, 10, 3,256, ZSTD_btopt }, /* level 19.*/ { 18, 19, 18, 11, 3,512, ZSTD_btultra }, /* level 20.*/ { 18, 19, 18, 12, 3,512, ZSTD_btultra }, /* level 21.*/ { 18, 19, 18, 13, 3,512, ZSTD_btultra }, /* level 22.*/ }, { /* for srcSize <= 128 KB */ /* W, C, H, S, L, T, strat */ { 17, 12, 12, 1, 5, 1, ZSTD_fast }, /* level 0 - not used */ { 17, 12, 13, 1, 6, 1, ZSTD_fast }, /* level 1 */ { 17, 13, 16, 1, 5, 1, ZSTD_fast }, /* level 2 */ { 17, 16, 16, 2, 5, 8, ZSTD_dfast }, /* level 3 */ { 17, 13, 15, 3, 4, 8, ZSTD_greedy }, /* level 4 */ { 17, 15, 17, 4, 4, 8, ZSTD_greedy }, /* level 5 */ { 17, 16, 17, 3, 4, 8, ZSTD_lazy }, /* level 6 */ { 17, 15, 17, 4, 4, 8, ZSTD_lazy2 }, /* level 7 */ { 17, 17, 17, 4, 4, 8, ZSTD_lazy2 }, /* level 8 */ { 17, 17, 17, 5, 4, 8, ZSTD_lazy2 }, /* level 9 */ { 17, 17, 17, 6, 4, 8, ZSTD_lazy2 }, /* level 10 */ { 17, 17, 17, 7, 4, 8, ZSTD_lazy2 }, /* level 11 */ { 17, 17, 17, 8, 4, 8, ZSTD_lazy2 }, /* level 12 */ { 17, 18, 17, 6, 4, 8, ZSTD_btlazy2 }, /* level 13.*/ { 17, 17, 17, 7, 3, 8, ZSTD_btopt }, /* level 14.*/ { 17, 17, 17, 7, 3, 16, ZSTD_btopt }, /* level 15.*/ { 17, 18, 17, 7, 3, 32, ZSTD_btopt }, /* level 16.*/ { 17, 18, 17, 7, 3, 64, ZSTD_btopt }, /* level 17.*/ { 17, 18, 17, 7, 3,256, ZSTD_btopt }, /* level 18.*/ { 17, 18, 17, 8, 3,256, ZSTD_btopt }, /* level 19.*/ { 17, 18, 17, 9, 3,256, ZSTD_btultra }, /* level 20.*/ { 17, 18, 17, 10, 3,256, ZSTD_btultra }, /* level 21.*/ { 17, 18, 17, 11, 3,512, ZSTD_btultra }, /* level 22.*/ }, { /* for srcSize <= 16 KB */ /* W, C, H, S, L, T, strat */ { 14, 12, 13, 1, 5, 1, ZSTD_fast }, /* base for negative levels */ { 14, 14, 14, 1, 6, 1, ZSTD_fast }, /* level 1 */ { 14, 14, 14, 1, 4, 1, ZSTD_fast }, /* level 2 */ { 14, 14, 14, 1, 4, 6, ZSTD_dfast }, /* level 3.*/ { 14, 14, 14, 4, 4, 6, ZSTD_greedy }, /* level 4.*/ { 14, 14, 14, 3, 4, 6, ZSTD_lazy }, /* level 5.*/ { 14, 14, 14, 4, 4, 6, ZSTD_lazy2 }, /* level 6 */ { 14, 14, 14, 5, 4, 6, ZSTD_lazy2 }, /* level 7 */ { 14, 14, 14, 6, 4, 6, ZSTD_lazy2 }, /* level 8.*/ { 14, 15, 14, 6, 4, 6, ZSTD_btlazy2 }, /* level 9.*/ { 14, 15, 14, 3, 3, 6, ZSTD_btopt }, /* level 10.*/ { 14, 15, 14, 6, 3, 8, ZSTD_btopt }, /* level 11.*/ { 14, 15, 14, 6, 3, 16, ZSTD_btopt }, /* level 12.*/ { 14, 15, 14, 6, 3, 24, ZSTD_btopt }, /* level 13.*/ { 14, 15, 15, 6, 3, 48, ZSTD_btopt }, /* level 14.*/ { 14, 15, 15, 6, 3, 64, ZSTD_btopt }, /* level 15.*/ { 14, 15, 15, 6, 3, 96, ZSTD_btopt }, /* level 16.*/ { 14, 15, 15, 6, 3,128, ZSTD_btopt }, /* level 17.*/ { 14, 15, 15, 6, 3,256, ZSTD_btopt }, /* level 18.*/ { 14, 15, 15, 7, 3,256, ZSTD_btopt }, /* level 19.*/ { 14, 15, 15, 8, 3,256, ZSTD_btultra }, /* level 20.*/ { 14, 15, 15, 9, 3,256, ZSTD_btultra }, /* level 21.*/ { 14, 15, 15, 10, 3,256, ZSTD_btultra }, /* level 22.*/ }, }; /*! ZSTD_getCParams() : * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize. * Size values are optional, provide 0 if not known or unused */ ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize) { size_t const addedSize = srcSizeHint ? 0 : 500; U64 const rSize = srcSizeHint+dictSize ? srcSizeHint+dictSize+addedSize : (U64)-1; U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB); /* intentional underflow for srcSizeHint == 0 */ int row = compressionLevel; DEBUGLOG(5, "ZSTD_getCParams (cLevel=%i)", compressionLevel); if (compressionLevel == 0) row = ZSTD_CLEVEL_DEFAULT; /* 0 == default */ if (compressionLevel < 0) row = 0; /* entry 0 is baseline for fast mode */ if (compressionLevel > ZSTD_MAX_CLEVEL) row = ZSTD_MAX_CLEVEL; { ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row]; if (compressionLevel < 0) cp.targetLength = (unsigned)(-compressionLevel); /* acceleration factor */ return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize); } } /*! ZSTD_getParams() : * same as ZSTD_getCParams(), but @return a `ZSTD_parameters` object (instead of `ZSTD_compressionParameters`). * All fields of `ZSTD_frameParameters` are set to default (0) */ ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize) { ZSTD_parameters params; ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, srcSizeHint, dictSize); DEBUGLOG(5, "ZSTD_getParams (cLevel=%i)", compressionLevel); memset(¶ms, 0, sizeof(params)); params.cParams = cParams; params.fParams.contentSizeFlag = 1; return params; } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_compress_internal.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /* This header contains definitions * that shall **only** be used by modules within lib/compress. */ #ifndef ZSTD_COMPRESS_H #define ZSTD_COMPRESS_H /*-************************************* * Dependencies ***************************************/ #include "zstd_internal.h" #ifdef ZSTD_MULTITHREAD # include "zstdmt_compress.h" #endif #if defined (__cplusplus) extern "C" { #endif /*-************************************* * Constants ***************************************/ #define kSearchStrength 8 #define HASH_READ_SIZE 8 #define ZSTD_DUBT_UNSORTED_MARK 1 /* For btlazy2 strategy, index 1 now means "unsorted". It could be confused for a real successor at index "1", if sorted as larger than its predecessor. It's not a big deal though : candidate will just be sorted again. Additionnally, candidate position 1 will be lost. But candidate 1 cannot hide a large tree of candidates, so it's a minimal loss. The benefit is that ZSTD_DUBT_UNSORTED_MARK cannot be misdhandled after table re-use with a different strategy */ /*-************************************* * Context memory management ***************************************/ typedef enum { ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e; typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage; typedef struct ZSTD_prefixDict_s { const void* dict; size_t dictSize; ZSTD_dictContentType_e dictContentType; } ZSTD_prefixDict; typedef struct { U32 hufCTable[HUF_CTABLE_SIZE_U32(255)]; FSE_CTable offcodeCTable[FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)]; FSE_CTable matchlengthCTable[FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)]; FSE_CTable litlengthCTable[FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)]; HUF_repeat hufCTable_repeatMode; FSE_repeat offcode_repeatMode; FSE_repeat matchlength_repeatMode; FSE_repeat litlength_repeatMode; } ZSTD_entropyCTables_t; typedef struct { U32 off; U32 len; } ZSTD_match_t; typedef struct { int price; U32 off; U32 mlen; U32 litlen; U32 rep[ZSTD_REP_NUM]; } ZSTD_optimal_t; typedef struct { /* All tables are allocated inside cctx->workspace by ZSTD_resetCCtx_internal() */ U32* litFreq; /* table of literals statistics, of size 256 */ U32* litLengthFreq; /* table of litLength statistics, of size (MaxLL+1) */ U32* matchLengthFreq; /* table of matchLength statistics, of size (MaxML+1) */ U32* offCodeFreq; /* table of offCode statistics, of size (MaxOff+1) */ ZSTD_match_t* matchTable; /* list of found matches, of size ZSTD_OPT_NUM+1 */ ZSTD_optimal_t* priceTable; /* All positions tracked by optimal parser, of size ZSTD_OPT_NUM+1 */ U32 litSum; /* nb of literals */ U32 litLengthSum; /* nb of litLength codes */ U32 matchLengthSum; /* nb of matchLength codes */ U32 offCodeSum; /* nb of offset codes */ /* begin updated by ZSTD_setLog2Prices */ U32 log2litSum; /* pow2 to compare log2(litfreq) to */ U32 log2litLengthSum; /* pow2 to compare log2(llfreq) to */ U32 log2matchLengthSum; /* pow2 to compare log2(mlfreq) to */ U32 log2offCodeSum; /* pow2 to compare log2(offreq) to */ /* end : updated by ZSTD_setLog2Prices */ U32 staticPrices; /* prices follow a pre-defined cost structure, statistics are irrelevant */ } optState_t; typedef struct { ZSTD_entropyCTables_t entropy; U32 rep[ZSTD_REP_NUM]; } ZSTD_compressedBlockState_t; typedef struct { BYTE const* nextSrc; /* next block here to continue on current prefix */ BYTE const* base; /* All regular indexes relative to this position */ BYTE const* dictBase; /* extDict indexes relative to this position */ U32 dictLimit; /* below that point, need extDict */ U32 lowLimit; /* below that point, no more data */ } ZSTD_window_t; typedef struct { ZSTD_window_t window; /* State for window round buffer management */ U32 loadedDictEnd; /* index of end of dictionary */ U32 nextToUpdate; /* index from which to continue table update */ U32 nextToUpdate3; /* index from which to continue table update */ U32 hashLog3; /* dispatch table : larger == faster, more memory */ U32* hashTable; U32* hashTable3; U32* chainTable; optState_t opt; /* optimal parser state */ } ZSTD_matchState_t; typedef struct { ZSTD_compressedBlockState_t* prevCBlock; ZSTD_compressedBlockState_t* nextCBlock; ZSTD_matchState_t matchState; } ZSTD_blockState_t; typedef struct { U32 offset; U32 checksum; } ldmEntry_t; typedef struct { ZSTD_window_t window; /* State for the window round buffer management */ ldmEntry_t* hashTable; BYTE* bucketOffsets; /* Next position in bucket to insert entry */ U64 hashPower; /* Used to compute the rolling hash. * Depends on ldmParams.minMatchLength */ } ldmState_t; typedef struct { U32 enableLdm; /* 1 if enable long distance matching */ U32 hashLog; /* Log size of hashTable */ U32 bucketSizeLog; /* Log bucket size for collision resolution, at most 8 */ U32 minMatchLength; /* Minimum match length */ U32 hashEveryLog; /* Log number of entries to skip */ U32 windowLog; /* Window log for the LDM */ } ldmParams_t; typedef struct { U32 offset; U32 litLength; U32 matchLength; } rawSeq; typedef struct { rawSeq* seq; /* The start of the sequences */ size_t pos; /* The position where reading stopped. <= size. */ size_t size; /* The number of sequences. <= capacity. */ size_t capacity; /* The capacity of the `seq` pointer */ } rawSeqStore_t; struct ZSTD_CCtx_params_s { ZSTD_format_e format; ZSTD_compressionParameters cParams; ZSTD_frameParameters fParams; int compressionLevel; int disableLiteralCompression; int forceWindow; /* force back-references to respect limit of * 1< 63) ? ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength]; } /* ZSTD_MLcode() : * note : mlBase = matchLength - MINMATCH; * because it's the format it's stored in seqStore->sequences */ MEM_STATIC U32 ZSTD_MLcode(U32 mlBase) { static const BYTE ML_Code[128] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 }; static const U32 ML_deltaCode = 36; return (mlBase > 127) ? ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase]; } /*! ZSTD_storeSeq() : * Store a sequence (literal length, literals, offset code and match length code) into seqStore_t. * `offsetCode` : distance to match + 3 (values 1-3 are repCodes). * `mlBase` : matchLength - MINMATCH */ MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const void* literals, U32 offsetCode, size_t mlBase) { #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 6) static const BYTE* g_start = NULL; if (g_start==NULL) g_start = (const BYTE*)literals; /* note : index only works for compression within a single segment */ { U32 const pos = (U32)((const BYTE*)literals - g_start); DEBUGLOG(6, "Cpos%7u :%3u literals, match%3u bytes at dist.code%7u", pos, (U32)litLength, (U32)mlBase+MINMATCH, (U32)offsetCode); } #endif /* copy Literals */ assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + 128 KB); ZSTD_wildcopy(seqStorePtr->lit, literals, litLength); seqStorePtr->lit += litLength; /* literal Length */ if (litLength>0xFFFF) { assert(seqStorePtr->longLengthID == 0); /* there can only be a single long length */ seqStorePtr->longLengthID = 1; seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart); } seqStorePtr->sequences[0].litLength = (U16)litLength; /* match offset */ seqStorePtr->sequences[0].offset = offsetCode + 1; /* match Length */ if (mlBase>0xFFFF) { assert(seqStorePtr->longLengthID == 0); /* there can only be a single long length */ seqStorePtr->longLengthID = 2; seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart); } seqStorePtr->sequences[0].matchLength = (U16)mlBase; seqStorePtr->sequences++; } /*-************************************* * Match length counter ***************************************/ static unsigned ZSTD_NbCommonBytes (size_t val) { if (MEM_isLittleEndian()) { if (MEM_64bits()) { # if defined(_MSC_VER) && defined(_WIN64) unsigned long r = 0; _BitScanForward64( &r, (U64)val ); return (unsigned)(r>>3); # elif defined(__GNUC__) && (__GNUC__ >= 4) return (__builtin_ctzll((U64)val) >> 3); # else static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 }; return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58]; # endif } else { /* 32 bits */ # if defined(_MSC_VER) unsigned long r=0; _BitScanForward( &r, (U32)val ); return (unsigned)(r>>3); # elif defined(__GNUC__) && (__GNUC__ >= 3) return (__builtin_ctz((U32)val) >> 3); # else static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 }; return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; # endif } } else { /* Big Endian CPU */ if (MEM_64bits()) { # if defined(_MSC_VER) && defined(_WIN64) unsigned long r = 0; _BitScanReverse64( &r, val ); return (unsigned)(r>>3); # elif defined(__GNUC__) && (__GNUC__ >= 4) return (__builtin_clzll(val) >> 3); # else unsigned r; const unsigned n32 = sizeof(size_t)*4; /* calculate this way due to compiler complaining in 32-bits mode */ if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; } if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } r += (!val); return r; # endif } else { /* 32 bits */ # if defined(_MSC_VER) unsigned long r = 0; _BitScanReverse( &r, (unsigned long)val ); return (unsigned)(r>>3); # elif defined(__GNUC__) && (__GNUC__ >= 3) return (__builtin_clz((U32)val) >> 3); # else unsigned r; if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; } r += (!val); return r; # endif } } } MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* const pInLimit) { const BYTE* const pStart = pIn; const BYTE* const pInLoopLimit = pInLimit - (sizeof(size_t)-1); if (pIn < pInLoopLimit) { { size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn); if (diff) return ZSTD_NbCommonBytes(diff); } pIn+=sizeof(size_t); pMatch+=sizeof(size_t); while (pIn < pInLoopLimit) { size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn); if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; } pIn += ZSTD_NbCommonBytes(diff); return (size_t)(pIn - pStart); } } if (MEM_64bits() && (pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; } if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; } if ((pIn> (32-h) ; } MEM_STATIC size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h); } /* only in zstd_opt.h */ static const U32 prime4bytes = 2654435761U; static U32 ZSTD_hash4(U32 u, U32 h) { return (u * prime4bytes) >> (32-h) ; } static size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_read32(ptr), h); } static const U64 prime5bytes = 889523592379ULL; static size_t ZSTD_hash5(U64 u, U32 h) { return (size_t)(((u << (64-40)) * prime5bytes) >> (64-h)) ; } static size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h); } static const U64 prime6bytes = 227718039650203ULL; static size_t ZSTD_hash6(U64 u, U32 h) { return (size_t)(((u << (64-48)) * prime6bytes) >> (64-h)) ; } static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h); } static const U64 prime7bytes = 58295818150454627ULL; static size_t ZSTD_hash7(U64 u, U32 h) { return (size_t)(((u << (64-56)) * prime7bytes) >> (64-h)) ; } static size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h); } static const U64 prime8bytes = 0xCF1BBCDCB7A56463ULL; static size_t ZSTD_hash8(U64 u, U32 h) { return (size_t)(((u) * prime8bytes) >> (64-h)) ; } static size_t ZSTD_hash8Ptr(const void* p, U32 h) { return ZSTD_hash8(MEM_readLE64(p), h); } MEM_STATIC size_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls) { switch(mls) { default: case 4: return ZSTD_hash4Ptr(p, hBits); case 5: return ZSTD_hash5Ptr(p, hBits); case 6: return ZSTD_hash6Ptr(p, hBits); case 7: return ZSTD_hash7Ptr(p, hBits); case 8: return ZSTD_hash8Ptr(p, hBits); } } /*-************************************* * Round buffer management ***************************************/ /* Max current allowed */ #define ZSTD_CURRENT_MAX ((3U << 29) + (1U << ZSTD_WINDOWLOG_MAX)) /* Maximum chunk size before overflow correction needs to be called again */ #define ZSTD_CHUNKSIZE_MAX \ ( ((U32)-1) /* Maximum ending current index */ \ - ZSTD_CURRENT_MAX) /* Maximum beginning lowLimit */ /** * ZSTD_window_clear(): * Clears the window containing the history by simply setting it to empty. */ MEM_STATIC void ZSTD_window_clear(ZSTD_window_t* window) { size_t const endT = (size_t)(window->nextSrc - window->base); U32 const end = (U32)endT; window->lowLimit = end; window->dictLimit = end; } /** * ZSTD_window_hasExtDict(): * Returns non-zero if the window has a non-empty extDict. */ MEM_STATIC U32 ZSTD_window_hasExtDict(ZSTD_window_t const window) { return window.lowLimit < window.dictLimit; } /** * ZSTD_window_needOverflowCorrection(): * Returns non-zero if the indices are getting too large and need overflow * protection. */ MEM_STATIC U32 ZSTD_window_needOverflowCorrection(ZSTD_window_t const window, void const* srcEnd) { U32 const current = (U32)((BYTE const*)srcEnd - window.base); return current > ZSTD_CURRENT_MAX; } /** * ZSTD_window_correctOverflow(): * Reduces the indices to protect from index overflow. * Returns the correction made to the indices, which must be applied to every * stored index. * * The least significant cycleLog bits of the indices must remain the same, * which may be 0. Every index up to maxDist in the past must be valid. * NOTE: (maxDist & cycleMask) must be zero. */ MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog, U32 maxDist, void const* src) { /* preemptive overflow correction: * 1. correction is large enough: * lowLimit > (3<<29) ==> current > 3<<29 + 1< (3<<29 + 1< (3<<29) - (1< (3<<29) - (1<<30) (NOTE: chainLog <= 30) * > 1<<29 * * 2. (ip+ZSTD_CHUNKSIZE_MAX - cctx->base) doesn't overflow: * After correction, current is less than (1<base < 1<<32. * 3. (cctx->lowLimit + 1< 3<<29 + 1<base); U32 const newCurrent = (current & cycleMask) + maxDist; U32 const correction = current - newCurrent; assert((maxDist & cycleMask) == 0); assert(current > newCurrent); /* Loose bound, should be around 1<<29 (see above) */ assert(correction > 1<<28); window->base += correction; window->dictBase += correction; window->lowLimit -= correction; window->dictLimit -= correction; DEBUGLOG(4, "Correction of 0x%x bytes to lowLimit=0x%x", correction, window->lowLimit); return correction; } /** * ZSTD_window_enforceMaxDist(): * Updates lowLimit so that: * (srcEnd - base) - lowLimit == maxDist + loadedDictEnd * This allows a simple check that index >= lowLimit to see if index is valid. * This must be called before a block compression call, with srcEnd as the block * source end. * If loadedDictEndPtr is not NULL, we set it to zero once we update lowLimit. * This is because dictionaries are allowed to be referenced as long as the last * byte of the dictionary is in the window, but once they are out of range, * they cannot be referenced. If loadedDictEndPtr is NULL, we use * loadedDictEnd == 0. */ MEM_STATIC void ZSTD_window_enforceMaxDist(ZSTD_window_t* window, void const* srcEnd, U32 maxDist, U32* loadedDictEndPtr) { U32 const current = (U32)((BYTE const*)srcEnd - window->base); U32 loadedDictEnd = loadedDictEndPtr != NULL ? *loadedDictEndPtr : 0; if (current > maxDist + loadedDictEnd) { U32 const newLowLimit = current - maxDist; if (window->lowLimit < newLowLimit) window->lowLimit = newLowLimit; if (window->dictLimit < window->lowLimit) { DEBUGLOG(5, "Update dictLimit from %u to %u", window->dictLimit, window->lowLimit); window->dictLimit = window->lowLimit; } if (loadedDictEndPtr) *loadedDictEndPtr = 0; } } /** * ZSTD_window_update(): * Updates the window by appending [src, src + srcSize) to the window. * If it is not contiguous, the current prefix becomes the extDict, and we * forget about the extDict. Handles overlap of the prefix and extDict. * Returns non-zero if the segment is contiguous. */ MEM_STATIC U32 ZSTD_window_update(ZSTD_window_t* window, void const* src, size_t srcSize) { BYTE const* const ip = (BYTE const*)src; U32 contiguous = 1; /* Check if blocks follow each other */ if (src != window->nextSrc) { /* not contiguous */ size_t const distanceFromBase = (size_t)(window->nextSrc - window->base); DEBUGLOG(5, "Non contiguous blocks, new segment starts at %u", window->dictLimit); window->lowLimit = window->dictLimit; assert(distanceFromBase == (size_t)(U32)distanceFromBase); /* should never overflow */ window->dictLimit = (U32)distanceFromBase; window->dictBase = window->base; window->base = ip - distanceFromBase; // ms->nextToUpdate = window->dictLimit; if (window->dictLimit - window->lowLimit < HASH_READ_SIZE) window->lowLimit = window->dictLimit; /* too small extDict */ contiguous = 0; } window->nextSrc = ip + srcSize; /* if input and dictionary overlap : reduce dictionary (area presumed modified by input) */ if ( (ip+srcSize > window->dictBase + window->lowLimit) & (ip < window->dictBase + window->dictLimit)) { ptrdiff_t const highInputIdx = (ip + srcSize) - window->dictBase; U32 const lowLimitMax = (highInputIdx > (ptrdiff_t)window->dictLimit) ? window->dictLimit : (U32)highInputIdx; window->lowLimit = lowLimitMax; } return contiguous; } #if defined (__cplusplus) } #endif /* ============================================================== * Private declarations * These prototypes shall only be called from within lib/compress * ============================================================== */ /* ZSTD_getCParamsFromCCtxParams() : * cParams are built depending on compressionLevel, src size hints, * LDM and manually set compression parameters. */ ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams( const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize); /*! ZSTD_initCStream_internal() : * Private use only. Init streaming operation. * expects params to be valid. * must receive dict, or cdict, or none, but not both. * @return : 0, or an error code */ size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs, const void* dict, size_t dictSize, const ZSTD_CDict* cdict, ZSTD_CCtx_params params, unsigned long long pledgedSrcSize); /*! ZSTD_compressStream_generic() : * Private use only. To be called from zstdmt_compress.c in single-thread mode. */ size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input, ZSTD_EndDirective const flushMode); /*! ZSTD_getCParamsFromCDict() : * as the name implies */ ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict); /* ZSTD_compressBegin_advanced_internal() : * Private use only. To be called from zstdmt_compress.c. */ size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType, const ZSTD_CDict* cdict, ZSTD_CCtx_params params, unsigned long long pledgedSrcSize); /* ZSTD_compress_advanced_internal() : * Private use only. To be called from zstdmt_compress.c. */ size_t ZSTD_compress_advanced_internal(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict,size_t dictSize, ZSTD_CCtx_params params); /* ZSTD_writeLastEmptyBlock() : * output an empty Block with end-of-frame mark to complete a frame * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h)) * or an error code if `dstCapcity` is too small ( /* memcpy, memmove, memset */ #include "cpu.h" #include "mem.h" /* low level memory routines */ #define FSE_STATIC_LINKING_ONLY #include "fse.h" #define HUF_STATIC_LINKING_ONLY #include "huf.h" #include "zstd_internal.h" #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) # include "zstd_legacy.h" #endif /*-************************************* * Errors ***************************************/ #define ZSTD_isError ERR_isError /* for inlining */ #define FSE_isError ERR_isError #define HUF_isError ERR_isError /*_******************************************************* * Memory operations **********************************************************/ static void ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); } /*-************************************************************* * Context management ***************************************************************/ typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader, ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock, ZSTDds_decompressLastBlock, ZSTDds_checkChecksum, ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTD_dStage; typedef enum { zdss_init=0, zdss_loadHeader, zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage; typedef struct { U32 fastMode; U32 tableLog; } ZSTD_seqSymbol_header; typedef struct { U16 nextState; BYTE nbAdditionalBits; BYTE nbBits; U32 baseValue; } ZSTD_seqSymbol; #define SEQSYMBOL_TABLE_SIZE(log) (1 + (1 << (log))) typedef struct { ZSTD_seqSymbol LLTable[SEQSYMBOL_TABLE_SIZE(LLFSELog)]; ZSTD_seqSymbol OFTable[SEQSYMBOL_TABLE_SIZE(OffFSELog)]; ZSTD_seqSymbol MLTable[SEQSYMBOL_TABLE_SIZE(MLFSELog)]; HUF_DTable hufTable[HUF_DTABLE_SIZE(HufLog)]; /* can accommodate HUF_decompress4X */ U32 workspace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32]; U32 rep[ZSTD_REP_NUM]; } ZSTD_entropyDTables_t; struct ZSTD_DCtx_s { const ZSTD_seqSymbol* LLTptr; const ZSTD_seqSymbol* MLTptr; const ZSTD_seqSymbol* OFTptr; const HUF_DTable* HUFptr; ZSTD_entropyDTables_t entropy; const void* previousDstEnd; /* detect continuity */ const void* base; /* start of current segment */ const void* vBase; /* virtual start of previous segment if it was just before current one */ const void* dictEnd; /* end of previous segment */ size_t expected; ZSTD_frameHeader fParams; U64 decodedSize; blockType_e bType; /* used in ZSTD_decompressContinue(), store blockType between block header decoding and block decompression stages */ ZSTD_dStage stage; U32 litEntropy; U32 fseEntropy; XXH64_state_t xxhState; size_t headerSize; U32 dictID; ZSTD_format_e format; const BYTE* litPtr; ZSTD_customMem customMem; size_t litSize; size_t rleSize; size_t staticSize; int bmi2; /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */ /* streaming */ ZSTD_DDict* ddictLocal; const ZSTD_DDict* ddict; ZSTD_dStreamStage streamStage; char* inBuff; size_t inBuffSize; size_t inPos; size_t maxWindowSize; char* outBuff; size_t outBuffSize; size_t outStart; size_t outEnd; size_t lhSize; void* legacyContext; U32 previousLegacyVersion; U32 legacyVersion; U32 hostageByte; /* workspace */ BYTE litBuffer[ZSTD_BLOCKSIZE_MAX + WILDCOPY_OVERLENGTH]; BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX]; }; /* typedef'd to ZSTD_DCtx within "zstd.h" */ size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx) { if (dctx==NULL) return 0; /* support sizeof NULL */ return sizeof(*dctx) + ZSTD_sizeof_DDict(dctx->ddictLocal) + dctx->inBuffSize + dctx->outBuffSize; } size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); } static size_t ZSTD_startingInputLength(ZSTD_format_e format) { size_t const startingInputLength = (format==ZSTD_f_zstd1_magicless) ? ZSTD_frameHeaderSize_prefix - ZSTD_frameIdSize : ZSTD_frameHeaderSize_prefix; ZSTD_STATIC_ASSERT(ZSTD_FRAMEHEADERSIZE_PREFIX >= ZSTD_FRAMEIDSIZE); /* only supports formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless */ assert( (format == ZSTD_f_zstd1) || (format == ZSTD_f_zstd1_magicless) ); return startingInputLength; } static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx) { dctx->format = ZSTD_f_zstd1; /* ZSTD_decompressBegin() invokes ZSTD_startingInputLength() with argument dctx->format */ dctx->staticSize = 0; dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT; dctx->ddict = NULL; dctx->ddictLocal = NULL; dctx->inBuff = NULL; dctx->inBuffSize = 0; dctx->outBuffSize = 0; dctx->streamStage = zdss_init; dctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid()); } ZSTD_DCtx* ZSTD_initStaticDCtx(void *workspace, size_t workspaceSize) { ZSTD_DCtx* const dctx = (ZSTD_DCtx*) workspace; if ((size_t)workspace & 7) return NULL; /* 8-aligned */ if (workspaceSize < sizeof(ZSTD_DCtx)) return NULL; /* minimum size */ ZSTD_initDCtx_internal(dctx); dctx->staticSize = workspaceSize; dctx->inBuff = (char*)(dctx+1); return dctx; } ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem) { if (!customMem.customAlloc ^ !customMem.customFree) return NULL; { ZSTD_DCtx* const dctx = (ZSTD_DCtx*)ZSTD_malloc(sizeof(*dctx), customMem); if (!dctx) return NULL; dctx->customMem = customMem; dctx->legacyContext = NULL; dctx->previousLegacyVersion = 0; ZSTD_initDCtx_internal(dctx); return dctx; } } ZSTD_DCtx* ZSTD_createDCtx(void) { DEBUGLOG(3, "ZSTD_createDCtx"); return ZSTD_createDCtx_advanced(ZSTD_defaultCMem); } size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx) { if (dctx==NULL) return 0; /* support free on NULL */ if (dctx->staticSize) return ERROR(memory_allocation); /* not compatible with static DCtx */ { ZSTD_customMem const cMem = dctx->customMem; ZSTD_freeDDict(dctx->ddictLocal); dctx->ddictLocal = NULL; ZSTD_free(dctx->inBuff, cMem); dctx->inBuff = NULL; #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) if (dctx->legacyContext) ZSTD_freeLegacyStreamContext(dctx->legacyContext, dctx->previousLegacyVersion); #endif ZSTD_free(dctx, cMem); return 0; } } /* no longer useful */ void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx) { size_t const toCopy = (size_t)((char*)(&dstDCtx->inBuff) - (char*)dstDCtx); memcpy(dstDCtx, srcDCtx, toCopy); /* no need to copy workspace */ } /*-************************************************************* * Frame header decoding ***************************************************************/ /*! ZSTD_isFrame() : * Tells if the content of `buffer` starts with a valid Frame Identifier. * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0. * Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled. * Note 3 : Skippable Frame Identifiers are considered valid. */ unsigned ZSTD_isFrame(const void* buffer, size_t size) { if (size < ZSTD_frameIdSize) return 0; { U32 const magic = MEM_readLE32(buffer); if (magic == ZSTD_MAGICNUMBER) return 1; if ((magic & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) return 1; } #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) if (ZSTD_isLegacy(buffer, size)) return 1; #endif return 0; } /** ZSTD_frameHeaderSize_internal() : * srcSize must be large enough to reach header size fields. * note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless. * @return : size of the Frame Header * or an error code, which can be tested with ZSTD_isError() */ static size_t ZSTD_frameHeaderSize_internal(const void* src, size_t srcSize, ZSTD_format_e format) { size_t const minInputSize = ZSTD_startingInputLength(format); if (srcSize < minInputSize) return ERROR(srcSize_wrong); { BYTE const fhd = ((const BYTE*)src)[minInputSize-1]; U32 const dictID= fhd & 3; U32 const singleSegment = (fhd >> 5) & 1; U32 const fcsId = fhd >> 6; return minInputSize + !singleSegment + ZSTD_did_fieldSize[dictID] + ZSTD_fcs_fieldSize[fcsId] + (singleSegment && !fcsId); } } /** ZSTD_frameHeaderSize() : * srcSize must be >= ZSTD_frameHeaderSize_prefix. * @return : size of the Frame Header */ size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize) { return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1); } /** ZSTD_getFrameHeader_internal() : * decode Frame Header, or require larger `srcSize`. * note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless * @return : 0, `zfhPtr` is correctly filled, * >0, `srcSize` is too small, value is wanted `srcSize` amount, * or an error code, which can be tested using ZSTD_isError() */ static size_t ZSTD_getFrameHeader_internal(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format) { const BYTE* ip = (const BYTE*)src; size_t const minInputSize = ZSTD_startingInputLength(format); if (srcSize < minInputSize) return minInputSize; if ( (format != ZSTD_f_zstd1_magicless) && (MEM_readLE32(src) != ZSTD_MAGICNUMBER) ) { if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */ if (srcSize < ZSTD_skippableHeaderSize) return ZSTD_skippableHeaderSize; /* magic number + frame length */ memset(zfhPtr, 0, sizeof(*zfhPtr)); zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_frameIdSize); zfhPtr->frameType = ZSTD_skippableFrame; return 0; } return ERROR(prefix_unknown); } /* ensure there is enough `srcSize` to fully read/decode frame header */ { size_t const fhsize = ZSTD_frameHeaderSize_internal(src, srcSize, format); if (srcSize < fhsize) return fhsize; zfhPtr->headerSize = (U32)fhsize; } { BYTE const fhdByte = ip[minInputSize-1]; size_t pos = minInputSize; U32 const dictIDSizeCode = fhdByte&3; U32 const checksumFlag = (fhdByte>>2)&1; U32 const singleSegment = (fhdByte>>5)&1; U32 const fcsID = fhdByte>>6; U64 windowSize = 0; U32 dictID = 0; U64 frameContentSize = ZSTD_CONTENTSIZE_UNKNOWN; if ((fhdByte & 0x08) != 0) return ERROR(frameParameter_unsupported); /* reserved bits, must be zero */ if (!singleSegment) { BYTE const wlByte = ip[pos++]; U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN; if (windowLog > ZSTD_WINDOWLOG_MAX) return ERROR(frameParameter_windowTooLarge); windowSize = (1ULL << windowLog); windowSize += (windowSize >> 3) * (wlByte&7); } switch(dictIDSizeCode) { default: assert(0); /* impossible */ case 0 : break; case 1 : dictID = ip[pos]; pos++; break; case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break; case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break; } switch(fcsID) { default: assert(0); /* impossible */ case 0 : if (singleSegment) frameContentSize = ip[pos]; break; case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break; case 2 : frameContentSize = MEM_readLE32(ip+pos); break; case 3 : frameContentSize = MEM_readLE64(ip+pos); break; } if (singleSegment) windowSize = frameContentSize; zfhPtr->frameType = ZSTD_frame; zfhPtr->frameContentSize = frameContentSize; zfhPtr->windowSize = windowSize; zfhPtr->blockSizeMax = (unsigned) MIN(windowSize, ZSTD_BLOCKSIZE_MAX); zfhPtr->dictID = dictID; zfhPtr->checksumFlag = checksumFlag; } return 0; } /** ZSTD_getFrameHeader() : * decode Frame Header, or require larger `srcSize`. * note : this function does not consume input, it only reads it. * @return : 0, `zfhPtr` is correctly filled, * >0, `srcSize` is too small, value is wanted `srcSize` amount, * or an error code, which can be tested using ZSTD_isError() */ size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize) { return ZSTD_getFrameHeader_internal(zfhPtr, src, srcSize, ZSTD_f_zstd1); } /** ZSTD_getFrameContentSize() : * compatible with legacy mode * @return : decompressed size of the single frame pointed to be `src` if known, otherwise * - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined * - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) */ unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize) { #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) if (ZSTD_isLegacy(src, srcSize)) { unsigned long long const ret = ZSTD_getDecompressedSize_legacy(src, srcSize); return ret == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : ret; } #endif { ZSTD_frameHeader zfh; if (ZSTD_getFrameHeader(&zfh, src, srcSize) != 0) return ZSTD_CONTENTSIZE_ERROR; if (zfh.frameType == ZSTD_skippableFrame) { return 0; } else { return zfh.frameContentSize; } } } /** ZSTD_findDecompressedSize() : * compatible with legacy mode * `srcSize` must be the exact length of some number of ZSTD compressed and/or * skippable frames * @return : decompressed size of the frames contained */ unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize) { unsigned long long totalDstSize = 0; while (srcSize >= ZSTD_frameHeaderSize_prefix) { U32 const magicNumber = MEM_readLE32(src); if ((magicNumber & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) { size_t skippableSize; if (srcSize < ZSTD_skippableHeaderSize) return ERROR(srcSize_wrong); skippableSize = MEM_readLE32((const BYTE *)src + ZSTD_frameIdSize) + ZSTD_skippableHeaderSize; if (srcSize < skippableSize) { return ZSTD_CONTENTSIZE_ERROR; } src = (const BYTE *)src + skippableSize; srcSize -= skippableSize; continue; } { unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize); if (ret >= ZSTD_CONTENTSIZE_ERROR) return ret; /* check for overflow */ if (totalDstSize + ret < totalDstSize) return ZSTD_CONTENTSIZE_ERROR; totalDstSize += ret; } { size_t const frameSrcSize = ZSTD_findFrameCompressedSize(src, srcSize); if (ZSTD_isError(frameSrcSize)) { return ZSTD_CONTENTSIZE_ERROR; } src = (const BYTE *)src + frameSrcSize; srcSize -= frameSrcSize; } } /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */ if (srcSize) return ZSTD_CONTENTSIZE_ERROR; return totalDstSize; } /** ZSTD_getDecompressedSize() : * compatible with legacy mode * @return : decompressed size if known, 0 otherwise note : 0 can mean any of the following : - frame content is empty - decompressed size field is not present in frame header - frame header unknown / not supported - frame header not complete (`srcSize` too small) */ unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize) { unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize); ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_ERROR < ZSTD_CONTENTSIZE_UNKNOWN); return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret; } /** ZSTD_decodeFrameHeader() : * `headerSize` must be the size provided by ZSTD_frameHeaderSize(). * @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */ static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize) { size_t const result = ZSTD_getFrameHeader_internal(&(dctx->fParams), src, headerSize, dctx->format); if (ZSTD_isError(result)) return result; /* invalid header */ if (result>0) return ERROR(srcSize_wrong); /* headerSize too small */ if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID)) return ERROR(dictionary_wrong); if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0); return 0; } /*-************************************************************* * Block decoding ***************************************************************/ /*! ZSTD_getcBlockSize() : * Provides the size of compressed block from block header `src` */ size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr) { if (srcSize < ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); { U32 const cBlockHeader = MEM_readLE24(src); U32 const cSize = cBlockHeader >> 3; bpPtr->lastBlock = cBlockHeader & 1; bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3); bpPtr->origSize = cSize; /* only useful for RLE */ if (bpPtr->blockType == bt_rle) return 1; if (bpPtr->blockType == bt_reserved) return ERROR(corruption_detected); return cSize; } } static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize) { if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall); memcpy(dst, src, srcSize); return srcSize; } static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize, size_t regenSize) { if (srcSize != 1) return ERROR(srcSize_wrong); if (regenSize > dstCapacity) return ERROR(dstSize_tooSmall); memset(dst, *(const BYTE*)src, regenSize); return regenSize; } /*! ZSTD_decodeLiteralsBlock() : * @return : nb of bytes read from src (< srcSize ) * note : symbol not declared but exposed for fullbench */ size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx, const void* src, size_t srcSize) /* note : srcSize < BLOCKSIZE */ { if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected); { const BYTE* const istart = (const BYTE*) src; symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3); switch(litEncType) { case set_repeat: if (dctx->litEntropy==0) return ERROR(dictionary_corrupted); /* fall-through */ case set_compressed: if (srcSize < 5) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3 */ { size_t lhSize, litSize, litCSize; U32 singleStream=0; U32 const lhlCode = (istart[0] >> 2) & 3; U32 const lhc = MEM_readLE32(istart); switch(lhlCode) { case 0: case 1: default: /* note : default is impossible, since lhlCode into [0..3] */ /* 2 - 2 - 10 - 10 */ singleStream = !lhlCode; lhSize = 3; litSize = (lhc >> 4) & 0x3FF; litCSize = (lhc >> 14) & 0x3FF; break; case 2: /* 2 - 2 - 14 - 14 */ lhSize = 4; litSize = (lhc >> 4) & 0x3FFF; litCSize = lhc >> 18; break; case 3: /* 2 - 2 - 18 - 18 */ lhSize = 5; litSize = (lhc >> 4) & 0x3FFFF; litCSize = (lhc >> 22) + (istart[4] << 10); break; } if (litSize > ZSTD_BLOCKSIZE_MAX) return ERROR(corruption_detected); if (litCSize + lhSize > srcSize) return ERROR(corruption_detected); if (HUF_isError((litEncType==set_repeat) ? ( singleStream ? HUF_decompress1X_usingDTable_bmi2(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->HUFptr, dctx->bmi2) : HUF_decompress4X_usingDTable_bmi2(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->HUFptr, dctx->bmi2) ) : ( singleStream ? HUF_decompress1X2_DCtx_wksp_bmi2(dctx->entropy.hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->entropy.workspace, sizeof(dctx->entropy.workspace), dctx->bmi2) : HUF_decompress4X_hufOnly_wksp_bmi2(dctx->entropy.hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->entropy.workspace, sizeof(dctx->entropy.workspace), dctx->bmi2)))) return ERROR(corruption_detected); dctx->litPtr = dctx->litBuffer; dctx->litSize = litSize; dctx->litEntropy = 1; if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable; memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); return litCSize + lhSize; } case set_basic: { size_t litSize, lhSize; U32 const lhlCode = ((istart[0]) >> 2) & 3; switch(lhlCode) { case 0: case 2: default: /* note : default is impossible, since lhlCode into [0..3] */ lhSize = 1; litSize = istart[0] >> 3; break; case 1: lhSize = 2; litSize = MEM_readLE16(istart) >> 4; break; case 3: lhSize = 3; litSize = MEM_readLE24(istart) >> 4; break; } if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */ if (litSize+lhSize > srcSize) return ERROR(corruption_detected); memcpy(dctx->litBuffer, istart+lhSize, litSize); dctx->litPtr = dctx->litBuffer; dctx->litSize = litSize; memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); return lhSize+litSize; } /* direct reference into compressed stream */ dctx->litPtr = istart+lhSize; dctx->litSize = litSize; return lhSize+litSize; } case set_rle: { U32 const lhlCode = ((istart[0]) >> 2) & 3; size_t litSize, lhSize; switch(lhlCode) { case 0: case 2: default: /* note : default is impossible, since lhlCode into [0..3] */ lhSize = 1; litSize = istart[0] >> 3; break; case 1: lhSize = 2; litSize = MEM_readLE16(istart) >> 4; break; case 3: lhSize = 3; litSize = MEM_readLE24(istart) >> 4; if (srcSize<4) return ERROR(corruption_detected); /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */ break; } if (litSize > ZSTD_BLOCKSIZE_MAX) return ERROR(corruption_detected); memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH); dctx->litPtr = dctx->litBuffer; dctx->litSize = litSize; return lhSize+1; } default: return ERROR(corruption_detected); /* impossible */ } } } /* Default FSE distribution tables. * These are pre-calculated FSE decoding tables using default distributions as defined in specification : * https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#default-distributions * They were generated programmatically with following method : * - start from default distributions, present in /lib/common/zstd_internal.h * - generate tables normally, using ZSTD_buildFSETable() * - printout the content of tables * - pretify output, report below, test with fuzzer to ensure it's correct */ /* Default FSE distribution table for Literal Lengths */ static const ZSTD_seqSymbol LL_defaultDTable[(1<tableLog = 0; DTableH->fastMode = 0; cell->nbBits = 0; cell->nextState = 0; assert(nbAddBits < 255); cell->nbAdditionalBits = (BYTE)nbAddBits; cell->baseValue = baseValue; } /* ZSTD_buildFSETable() : * generate FSE decoding table for one symbol (ll, ml or off) */ static void ZSTD_buildFSETable(ZSTD_seqSymbol* dt, const short* normalizedCounter, unsigned maxSymbolValue, const U32* baseValue, const U32* nbAdditionalBits, unsigned tableLog) { ZSTD_seqSymbol* const tableDecode = dt+1; U16 symbolNext[MaxSeq+1]; U32 const maxSV1 = maxSymbolValue + 1; U32 const tableSize = 1 << tableLog; U32 highThreshold = tableSize-1; /* Sanity Checks */ assert(maxSymbolValue <= MaxSeq); assert(tableLog <= MaxFSELog); /* Init, lay down lowprob symbols */ { ZSTD_seqSymbol_header DTableH; DTableH.tableLog = tableLog; DTableH.fastMode = 1; { S16 const largeLimit= (S16)(1 << (tableLog-1)); U32 s; for (s=0; s= largeLimit) DTableH.fastMode=0; symbolNext[s] = normalizedCounter[s]; } } } memcpy(dt, &DTableH, sizeof(DTableH)); } /* Spread symbols */ { U32 const tableMask = tableSize-1; U32 const step = FSE_TABLESTEP(tableSize); U32 s, position = 0; for (s=0; s highThreshold) position = (position + step) & tableMask; /* lowprob area */ } } assert(position == 0); /* position must reach all cells once, otherwise normalizedCounter is incorrect */ } /* Build Decoding table */ { U32 u; for (u=0; u max) return ERROR(corruption_detected); { U32 const symbol = *(const BYTE*)src; U32 const baseline = baseValue[symbol]; U32 const nbBits = nbAdditionalBits[symbol]; ZSTD_buildSeqTable_rle(DTableSpace, baseline, nbBits); } *DTablePtr = DTableSpace; return 1; case set_basic : *DTablePtr = defaultTable; return 0; case set_repeat: if (!flagRepeatTable) return ERROR(corruption_detected); return 0; case set_compressed : { U32 tableLog; S16 norm[MaxSeq+1]; size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize); if (FSE_isError(headerSize)) return ERROR(corruption_detected); if (tableLog > maxLog) return ERROR(corruption_detected); ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog); *DTablePtr = DTableSpace; return headerSize; } default : /* impossible */ assert(0); return ERROR(GENERIC); } } static const U32 LL_base[MaxLL+1] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000 }; static const U32 OF_base[MaxOff+1] = { 0, 1, 1, 5, 0xD, 0x1D, 0x3D, 0x7D, 0xFD, 0x1FD, 0x3FD, 0x7FD, 0xFFD, 0x1FFD, 0x3FFD, 0x7FFD, 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD, 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD, 0x1FFFFFFD, 0x3FFFFFFD, 0x7FFFFFFD }; static const U32 OF_bits[MaxOff+1] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 }; static const U32 ML_base[MaxML+1] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 39, 41, 43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803, 0x1003, 0x2003, 0x4003, 0x8003, 0x10003 }; size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr, const void* src, size_t srcSize) { const BYTE* const istart = (const BYTE* const)src; const BYTE* const iend = istart + srcSize; const BYTE* ip = istart; DEBUGLOG(5, "ZSTD_decodeSeqHeaders"); /* check */ if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong); /* SeqHead */ { int nbSeq = *ip++; if (!nbSeq) { *nbSeqPtr=0; return 1; } if (nbSeq > 0x7F) { if (nbSeq == 0xFF) { if (ip+2 > iend) return ERROR(srcSize_wrong); nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2; } else { if (ip >= iend) return ERROR(srcSize_wrong); nbSeq = ((nbSeq-0x80)<<8) + *ip++; } } *nbSeqPtr = nbSeq; } /* FSE table descriptors */ if (ip+4 > iend) return ERROR(srcSize_wrong); /* minimum possible size */ { symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6); symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3); symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3); ip++; /* Build DTables */ { size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_base, LL_bits, LL_defaultDTable, dctx->fseEntropy); if (ZSTD_isError(llhSize)) return ERROR(corruption_detected); ip += llhSize; } { size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, OFtype, MaxOff, OffFSELog, ip, iend-ip, OF_base, OF_bits, OF_defaultDTable, dctx->fseEntropy); if (ZSTD_isError(ofhSize)) return ERROR(corruption_detected); ip += ofhSize; } { size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_base, ML_bits, ML_defaultDTable, dctx->fseEntropy); if (ZSTD_isError(mlhSize)) return ERROR(corruption_detected); ip += mlhSize; } } return ip-istart; } typedef struct { size_t litLength; size_t matchLength; size_t offset; const BYTE* match; } seq_t; typedef struct { size_t state; const ZSTD_seqSymbol* table; } ZSTD_fseState; typedef struct { BIT_DStream_t DStream; ZSTD_fseState stateLL; ZSTD_fseState stateOffb; ZSTD_fseState stateML; size_t prevOffset[ZSTD_REP_NUM]; const BYTE* prefixStart; const BYTE* dictEnd; size_t pos; } seqState_t; FORCE_NOINLINE size_t ZSTD_execSequenceLast7(BYTE* op, BYTE* const oend, seq_t sequence, const BYTE** litPtr, const BYTE* const litLimit, const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd) { BYTE* const oLitEnd = op + sequence.litLength; size_t const sequenceLength = sequence.litLength + sequence.matchLength; BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */ BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; const BYTE* const iLitEnd = *litPtr + sequence.litLength; const BYTE* match = oLitEnd - sequence.offset; /* check */ if (oMatchEnd>oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */ if (iLitEnd > litLimit) return ERROR(corruption_detected); /* over-read beyond lit buffer */ if (oLitEnd <= oend_w) return ERROR(GENERIC); /* Precondition */ /* copy literals */ if (op < oend_w) { ZSTD_wildcopy(op, *litPtr, oend_w - op); *litPtr += oend_w - op; op = oend_w; } while (op < oLitEnd) *op++ = *(*litPtr)++; /* copy Match */ if (sequence.offset > (size_t)(oLitEnd - base)) { /* offset beyond prefix */ if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected); match = dictEnd - (base-match); if (match + sequence.matchLength <= dictEnd) { memmove(oLitEnd, match, sequence.matchLength); return sequenceLength; } /* span extDict & currentPrefixSegment */ { size_t const length1 = dictEnd - match; memmove(oLitEnd, match, length1); op = oLitEnd + length1; sequence.matchLength -= length1; match = base; } } while (op < oMatchEnd) *op++ = *match++; return sequenceLength; } HINT_INLINE size_t ZSTD_execSequence(BYTE* op, BYTE* const oend, seq_t sequence, const BYTE** litPtr, const BYTE* const litLimit, const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd) { BYTE* const oLitEnd = op + sequence.litLength; size_t const sequenceLength = sequence.litLength + sequence.matchLength; BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */ BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; const BYTE* const iLitEnd = *litPtr + sequence.litLength; const BYTE* match = oLitEnd - sequence.offset; /* check */ if (oMatchEnd>oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */ if (iLitEnd > litLimit) return ERROR(corruption_detected); /* over-read beyond lit buffer */ if (oLitEnd>oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, base, vBase, dictEnd); /* copy Literals */ ZSTD_copy8(op, *litPtr); if (sequence.litLength > 8) ZSTD_wildcopy(op+8, (*litPtr)+8, sequence.litLength - 8); /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */ op = oLitEnd; *litPtr = iLitEnd; /* update for next sequence */ /* copy Match */ if (sequence.offset > (size_t)(oLitEnd - base)) { /* offset beyond prefix -> go into extDict */ if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected); match = dictEnd + (match - base); if (match + sequence.matchLength <= dictEnd) { memmove(oLitEnd, match, sequence.matchLength); return sequenceLength; } /* span extDict & currentPrefixSegment */ { size_t const length1 = dictEnd - match; memmove(oLitEnd, match, length1); op = oLitEnd + length1; sequence.matchLength -= length1; match = base; if (op > oend_w || sequence.matchLength < MINMATCH) { U32 i; for (i = 0; i < sequence.matchLength; ++i) op[i] = match[i]; return sequenceLength; } } } /* Requirement: op <= oend_w && sequence.matchLength >= MINMATCH */ /* match within prefix */ if (sequence.offset < 8) { /* close range match, overlap */ static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */ static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */ int const sub2 = dec64table[sequence.offset]; op[0] = match[0]; op[1] = match[1]; op[2] = match[2]; op[3] = match[3]; match += dec32table[sequence.offset]; ZSTD_copy4(op+4, match); match -= sub2; } else { ZSTD_copy8(op, match); } op += 8; match += 8; if (oMatchEnd > oend-(16-MINMATCH)) { if (op < oend_w) { ZSTD_wildcopy(op, match, oend_w - op); match += oend_w - op; op = oend_w; } while (op < oMatchEnd) *op++ = *match++; } else { ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8 */ } return sequenceLength; } HINT_INLINE size_t ZSTD_execSequenceLong(BYTE* op, BYTE* const oend, seq_t sequence, const BYTE** litPtr, const BYTE* const litLimit, const BYTE* const prefixStart, const BYTE* const dictStart, const BYTE* const dictEnd) { BYTE* const oLitEnd = op + sequence.litLength; size_t const sequenceLength = sequence.litLength + sequence.matchLength; BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */ BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; const BYTE* const iLitEnd = *litPtr + sequence.litLength; const BYTE* match = sequence.match; /* check */ if (oMatchEnd > oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */ if (iLitEnd > litLimit) return ERROR(corruption_detected); /* over-read beyond lit buffer */ if (oLitEnd > oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, prefixStart, dictStart, dictEnd); /* copy Literals */ ZSTD_copy8(op, *litPtr); /* note : op <= oLitEnd <= oend_w == oend - 8 */ if (sequence.litLength > 8) ZSTD_wildcopy(op+8, (*litPtr)+8, sequence.litLength - 8); /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */ op = oLitEnd; *litPtr = iLitEnd; /* update for next sequence */ /* copy Match */ if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { /* offset beyond prefix */ if (sequence.offset > (size_t)(oLitEnd - dictStart)) return ERROR(corruption_detected); if (match + sequence.matchLength <= dictEnd) { memmove(oLitEnd, match, sequence.matchLength); return sequenceLength; } /* span extDict & currentPrefixSegment */ { size_t const length1 = dictEnd - match; memmove(oLitEnd, match, length1); op = oLitEnd + length1; sequence.matchLength -= length1; match = prefixStart; if (op > oend_w || sequence.matchLength < MINMATCH) { U32 i; for (i = 0; i < sequence.matchLength; ++i) op[i] = match[i]; return sequenceLength; } } } assert(op <= oend_w); assert(sequence.matchLength >= MINMATCH); /* match within prefix */ if (sequence.offset < 8) { /* close range match, overlap */ static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; /* added */ static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 }; /* subtracted */ int const sub2 = dec64table[sequence.offset]; op[0] = match[0]; op[1] = match[1]; op[2] = match[2]; op[3] = match[3]; match += dec32table[sequence.offset]; ZSTD_copy4(op+4, match); match -= sub2; } else { ZSTD_copy8(op, match); } op += 8; match += 8; if (oMatchEnd > oend-(16-MINMATCH)) { if (op < oend_w) { ZSTD_wildcopy(op, match, oend_w - op); match += oend_w - op; op = oend_w; } while (op < oMatchEnd) *op++ = *match++; } else { ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8); /* works even if matchLength < 8 */ } return sequenceLength; } static void ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt) { const void* ptr = dt; const ZSTD_seqSymbol_header* const DTableH = (const ZSTD_seqSymbol_header*)ptr; DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog); DEBUGLOG(6, "ZSTD_initFseState : val=%u using %u bits", (U32)DStatePtr->state, DTableH->tableLog); BIT_reloadDStream(bitD); DStatePtr->table = dt + 1; } FORCE_INLINE_TEMPLATE void ZSTD_updateFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD) { ZSTD_seqSymbol const DInfo = DStatePtr->table[DStatePtr->state]; U32 const nbBits = DInfo.nbBits; size_t const lowBits = BIT_readBits(bitD, nbBits); DStatePtr->state = DInfo.nextState + lowBits; } /* We need to add at most (ZSTD_WINDOWLOG_MAX_32 - 1) bits to read the maximum * offset bits. But we can only read at most (STREAM_ACCUMULATOR_MIN_32 - 1) * bits before reloading. This value is the maximum number of bytes we read * after reloading when we are decoding long offets. */ #define LONG_OFFSETS_MAX_EXTRA_BITS_32 \ (ZSTD_WINDOWLOG_MAX_32 > STREAM_ACCUMULATOR_MIN_32 \ ? ZSTD_WINDOWLOG_MAX_32 - STREAM_ACCUMULATOR_MIN_32 \ : 0) typedef enum { ZSTD_lo_isRegularOffset, ZSTD_lo_isLongOffset=1 } ZSTD_longOffset_e; FORCE_INLINE_TEMPLATE seq_t ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets) { seq_t seq; U32 const llBits = seqState->stateLL.table[seqState->stateLL.state].nbAdditionalBits; U32 const mlBits = seqState->stateML.table[seqState->stateML.state].nbAdditionalBits; U32 const ofBits = seqState->stateOffb.table[seqState->stateOffb.state].nbAdditionalBits; U32 const totalBits = llBits+mlBits+ofBits; U32 const llBase = seqState->stateLL.table[seqState->stateLL.state].baseValue; U32 const mlBase = seqState->stateML.table[seqState->stateML.state].baseValue; U32 const ofBase = seqState->stateOffb.table[seqState->stateOffb.state].baseValue; /* sequence */ { size_t offset; if (!ofBits) offset = 0; else { ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1); ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5); assert(ofBits <= MaxOff); if (MEM_32bits() && longOffsets && (ofBits >= STREAM_ACCUMULATOR_MIN_32)) { U32 const extraBits = ofBits - MIN(ofBits, 32 - seqState->DStream.bitsConsumed); offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits); BIT_reloadDStream(&seqState->DStream); if (extraBits) offset += BIT_readBitsFast(&seqState->DStream, extraBits); assert(extraBits <= LONG_OFFSETS_MAX_EXTRA_BITS_32); /* to avoid another reload */ } else { offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */ if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); } } if (ofBits <= 1) { offset += (llBase==0); if (offset) { size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset]; temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; seqState->prevOffset[1] = seqState->prevOffset[0]; seqState->prevOffset[0] = offset = temp; } else { /* offset == 0 */ offset = seqState->prevOffset[0]; } } else { seqState->prevOffset[2] = seqState->prevOffset[1]; seqState->prevOffset[1] = seqState->prevOffset[0]; seqState->prevOffset[0] = offset; } seq.offset = offset; } seq.matchLength = mlBase + ((mlBits>0) ? BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/) : 0); /* <= 16 bits */ if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32)) BIT_reloadDStream(&seqState->DStream); if (MEM_64bits() && (totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) BIT_reloadDStream(&seqState->DStream); /* Ensure there are enough bits to read the rest of data in 64-bit mode. */ ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64); seq.litLength = llBase + ((llBits>0) ? BIT_readBitsFast(&seqState->DStream, llBits/*>0*/) : 0); /* <= 16 bits */ if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); DEBUGLOG(6, "seq: litL=%u, matchL=%u, offset=%u", (U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset); /* ANS state update */ ZSTD_updateFseState(&seqState->stateLL, &seqState->DStream); /* <= 9 bits */ ZSTD_updateFseState(&seqState->stateML, &seqState->DStream); /* <= 9 bits */ if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); /* <= 18 bits */ ZSTD_updateFseState(&seqState->stateOffb, &seqState->DStream); /* <= 8 bits */ return seq; } FORCE_INLINE_TEMPLATE size_t ZSTD_decompressSequences_body( ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* seqStart, size_t seqSize, int nbSeq, const ZSTD_longOffset_e isLongOffset) { const BYTE* ip = (const BYTE*)seqStart; const BYTE* const iend = ip + seqSize; BYTE* const ostart = (BYTE* const)dst; BYTE* const oend = ostart + maxDstSize; BYTE* op = ostart; const BYTE* litPtr = dctx->litPtr; const BYTE* const litEnd = litPtr + dctx->litSize; const BYTE* const base = (const BYTE*) (dctx->base); const BYTE* const vBase = (const BYTE*) (dctx->vBase); const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); DEBUGLOG(5, "ZSTD_decompressSequences"); /* Regen sequences */ if (nbSeq) { seqState_t seqState; dctx->fseEntropy = 1; { U32 i; for (i=0; ientropy.rep[i]; } CHECK_E(BIT_initDStream(&seqState.DStream, ip, iend-ip), corruption_detected); ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr); ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr); for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && nbSeq ; ) { nbSeq--; { seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset); size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd); DEBUGLOG(6, "regenerated sequence size : %u", (U32)oneSeqSize); if (ZSTD_isError(oneSeqSize)) return oneSeqSize; op += oneSeqSize; } } /* check if reached exact end */ DEBUGLOG(5, "ZSTD_decompressSequences: after decode loop, remaining nbSeq : %i", nbSeq); if (nbSeq) return ERROR(corruption_detected); /* save reps for next block */ { U32 i; for (i=0; ientropy.rep[i] = (U32)(seqState.prevOffset[i]); } } /* last literal segment */ { size_t const lastLLSize = litEnd - litPtr; if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall); memcpy(op, litPtr, lastLLSize); op += lastLLSize; } return op-ostart; } static size_t ZSTD_decompressSequences_default(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* seqStart, size_t seqSize, int nbSeq, const ZSTD_longOffset_e isLongOffset) { return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset); } FORCE_INLINE_TEMPLATE seq_t ZSTD_decodeSequenceLong(seqState_t* seqState, ZSTD_longOffset_e const longOffsets) { seq_t seq; U32 const llBits = seqState->stateLL.table[seqState->stateLL.state].nbAdditionalBits; U32 const mlBits = seqState->stateML.table[seqState->stateML.state].nbAdditionalBits; U32 const ofBits = seqState->stateOffb.table[seqState->stateOffb.state].nbAdditionalBits; U32 const totalBits = llBits+mlBits+ofBits; U32 const llBase = seqState->stateLL.table[seqState->stateLL.state].baseValue; U32 const mlBase = seqState->stateML.table[seqState->stateML.state].baseValue; U32 const ofBase = seqState->stateOffb.table[seqState->stateOffb.state].baseValue; /* sequence */ { size_t offset; if (!ofBits) offset = 0; else { ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1); ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5); assert(ofBits <= MaxOff); if (MEM_32bits() && longOffsets) { U32 const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN_32-1); offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits); if (MEM_32bits() || extraBits) BIT_reloadDStream(&seqState->DStream); if (extraBits) offset += BIT_readBitsFast(&seqState->DStream, extraBits); } else { offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */ if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); } } if (ofBits <= 1) { offset += (llBase==0); if (offset) { size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset]; temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; seqState->prevOffset[1] = seqState->prevOffset[0]; seqState->prevOffset[0] = offset = temp; } else { offset = seqState->prevOffset[0]; } } else { seqState->prevOffset[2] = seqState->prevOffset[1]; seqState->prevOffset[1] = seqState->prevOffset[0]; seqState->prevOffset[0] = offset; } seq.offset = offset; } seq.matchLength = mlBase + ((mlBits>0) ? BIT_readBitsFast(&seqState->DStream, mlBits) : 0); /* <= 16 bits */ if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32)) BIT_reloadDStream(&seqState->DStream); if (MEM_64bits() && (totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) BIT_reloadDStream(&seqState->DStream); /* Verify that there is enough bits to read the rest of the data in 64-bit mode. */ ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64); seq.litLength = llBase + ((llBits>0) ? BIT_readBitsFast(&seqState->DStream, llBits) : 0); /* <= 16 bits */ if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); { size_t const pos = seqState->pos + seq.litLength; const BYTE* const matchBase = (seq.offset > pos) ? seqState->dictEnd : seqState->prefixStart; seq.match = matchBase + pos - seq.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. * No consequence though : no memory access will occur, overly large offset will be detected in ZSTD_execSequenceLong() */ seqState->pos = pos + seq.matchLength; } /* ANS state update */ ZSTD_updateFseState(&seqState->stateLL, &seqState->DStream); /* <= 9 bits */ ZSTD_updateFseState(&seqState->stateML, &seqState->DStream); /* <= 9 bits */ if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream); /* <= 18 bits */ ZSTD_updateFseState(&seqState->stateOffb, &seqState->DStream); /* <= 8 bits */ return seq; } FORCE_INLINE_TEMPLATE size_t ZSTD_decompressSequencesLong_body( ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* seqStart, size_t seqSize, int nbSeq, const ZSTD_longOffset_e isLongOffset) { const BYTE* ip = (const BYTE*)seqStart; const BYTE* const iend = ip + seqSize; BYTE* const ostart = (BYTE* const)dst; BYTE* const oend = ostart + maxDstSize; BYTE* op = ostart; const BYTE* litPtr = dctx->litPtr; const BYTE* const litEnd = litPtr + dctx->litSize; const BYTE* const prefixStart = (const BYTE*) (dctx->base); const BYTE* const dictStart = (const BYTE*) (dctx->vBase); const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); /* Regen sequences */ if (nbSeq) { #define STORED_SEQS 4 #define STOSEQ_MASK (STORED_SEQS-1) #define ADVANCED_SEQS 4 seq_t sequences[STORED_SEQS]; int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS); seqState_t seqState; int seqNb; dctx->fseEntropy = 1; { U32 i; for (i=0; ientropy.rep[i]; } seqState.prefixStart = prefixStart; seqState.pos = (size_t)(op-prefixStart); seqState.dictEnd = dictEnd; CHECK_E(BIT_initDStream(&seqState.DStream, ip, iend-ip), corruption_detected); ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr); ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr); /* prepare in advance */ for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNbentropy.rep[i] = (U32)(seqState.prevOffset[i]); } #undef STORED_SEQS #undef STOSEQ_MASK #undef ADVANCED_SEQS } /* last literal segment */ { size_t const lastLLSize = litEnd - litPtr; if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall); memcpy(op, litPtr, lastLLSize); op += lastLLSize; } return op-ostart; } static size_t ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* seqStart, size_t seqSize, int nbSeq, const ZSTD_longOffset_e isLongOffset) { return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset); } #if DYNAMIC_BMI2 static TARGET_ATTRIBUTE("bmi2") size_t ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* seqStart, size_t seqSize, int nbSeq, const ZSTD_longOffset_e isLongOffset) { return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset); } static TARGET_ATTRIBUTE("bmi2") size_t ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* seqStart, size_t seqSize, int nbSeq, const ZSTD_longOffset_e isLongOffset) { return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset); } #endif typedef size_t (*ZSTD_decompressSequences_t)( ZSTD_DCtx *dctx, void *dst, size_t maxDstSize, const void *seqStart, size_t seqSize, int nbSeq, const ZSTD_longOffset_e isLongOffset); static size_t ZSTD_decompressSequences(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* seqStart, size_t seqSize, int nbSeq, const ZSTD_longOffset_e isLongOffset) { DEBUGLOG(5, "ZSTD_decompressSequences"); #if DYNAMIC_BMI2 if (dctx->bmi2) { return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset); } #endif return ZSTD_decompressSequences_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset); } static size_t ZSTD_decompressSequencesLong(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* seqStart, size_t seqSize, int nbSeq, const ZSTD_longOffset_e isLongOffset) { DEBUGLOG(5, "ZSTD_decompressSequencesLong"); #if DYNAMIC_BMI2 if (dctx->bmi2) { return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset); } #endif return ZSTD_decompressSequencesLong_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset); } /* ZSTD_getLongOffsetsShare() : * condition : offTable must be valid * @return : "share" of long offsets (arbitrarily defined as > (1<<23)) * compared to maximum possible of (1< 22) total += 1; } assert(tableLog <= OffFSELog); total <<= (OffFSELog - tableLog); /* scale to OffFSELog */ return total; } static size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const int frame) { /* blockType == blockCompressed */ const BYTE* ip = (const BYTE*)src; /* isLongOffset must be true if there are long offsets. * Offsets are long if they are larger than 2^STREAM_ACCUMULATOR_MIN. * We don't expect that to be the case in 64-bit mode. * In block mode, window size is not known, so we have to be conservative. (note: but it could be evaluated from current-lowLimit) */ ZSTD_longOffset_e const isLongOffset = (ZSTD_longOffset_e)(MEM_32bits() && (!frame || dctx->fParams.windowSize > (1ULL << STREAM_ACCUMULATOR_MIN))); DEBUGLOG(5, "ZSTD_decompressBlock_internal (size : %u)", (U32)srcSize); if (srcSize >= ZSTD_BLOCKSIZE_MAX) return ERROR(srcSize_wrong); /* Decode literals section */ { size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize); DEBUGLOG(5, "ZSTD_decodeLiteralsBlock : %u", (U32)litCSize); if (ZSTD_isError(litCSize)) return litCSize; ip += litCSize; srcSize -= litCSize; } /* Build Decoding Tables */ { int nbSeq; size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize); if (ZSTD_isError(seqHSize)) return seqHSize; ip += seqHSize; srcSize -= seqHSize; if ( (!frame || dctx->fParams.windowSize > (1<<24)) && (nbSeq>0) ) { /* could probably use a larger nbSeq limit */ U32 const shareLongOffsets = ZSTD_getLongOffsetsShare(dctx->OFTptr); U32 const minShare = MEM_64bits() ? 7 : 20; /* heuristic values, correspond to 2.73% and 7.81% */ if (shareLongOffsets >= minShare) return ZSTD_decompressSequencesLong(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset); } return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset); } } static void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst) { if (dst != dctx->previousDstEnd) { /* not contiguous */ dctx->dictEnd = dctx->previousDstEnd; dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base)); dctx->base = dst; dctx->previousDstEnd = dst; } } size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) { size_t dSize; ZSTD_checkContinuity(dctx, dst); dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 0); dctx->previousDstEnd = (char*)dst + dSize; return dSize; } /** ZSTD_insertBlock() : insert `src` block into `dctx` history. Useful to track uncompressed blocks. */ ZSTDLIB_API size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize) { ZSTD_checkContinuity(dctx, blockStart); dctx->previousDstEnd = (const char*)blockStart + blockSize; return blockSize; } static size_t ZSTD_generateNxBytes(void* dst, size_t dstCapacity, BYTE byte, size_t length) { if (length > dstCapacity) return ERROR(dstSize_tooSmall); memset(dst, byte, length); return length; } /** ZSTD_findFrameCompressedSize() : * compatible with legacy mode * `src` must point to the start of a ZSTD frame, ZSTD legacy frame, or skippable frame * `srcSize` must be at least as large as the frame contained * @return : the compressed size of the frame starting at `src` */ size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize) { #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) if (ZSTD_isLegacy(src, srcSize)) return ZSTD_findFrameCompressedSizeLegacy(src, srcSize); #endif if ( (srcSize >= ZSTD_skippableHeaderSize) && (MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START ) { return ZSTD_skippableHeaderSize + MEM_readLE32((const BYTE*)src + ZSTD_frameIdSize); } else { const BYTE* ip = (const BYTE*)src; const BYTE* const ipstart = ip; size_t remainingSize = srcSize; ZSTD_frameHeader zfh; /* Extract Frame Header */ { size_t const ret = ZSTD_getFrameHeader(&zfh, src, srcSize); if (ZSTD_isError(ret)) return ret; if (ret > 0) return ERROR(srcSize_wrong); } ip += zfh.headerSize; remainingSize -= zfh.headerSize; /* Loop on each block */ while (1) { blockProperties_t blockProperties; size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties); if (ZSTD_isError(cBlockSize)) return cBlockSize; if (ZSTD_blockHeaderSize + cBlockSize > remainingSize) return ERROR(srcSize_wrong); ip += ZSTD_blockHeaderSize + cBlockSize; remainingSize -= ZSTD_blockHeaderSize + cBlockSize; if (blockProperties.lastBlock) break; } if (zfh.checksumFlag) { /* Final frame content checksum */ if (remainingSize < 4) return ERROR(srcSize_wrong); ip += 4; remainingSize -= 4; } return ip - ipstart; } } /*! ZSTD_decompressFrame() : * @dctx must be properly initialized */ static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void** srcPtr, size_t *srcSizePtr) { const BYTE* ip = (const BYTE*)(*srcPtr); BYTE* const ostart = (BYTE* const)dst; BYTE* const oend = ostart + dstCapacity; BYTE* op = ostart; size_t remainingSize = *srcSizePtr; /* check */ if (remainingSize < ZSTD_frameHeaderSize_min+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); /* Frame Header */ { size_t const frameHeaderSize = ZSTD_frameHeaderSize(ip, ZSTD_frameHeaderSize_prefix); if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize; if (remainingSize < frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); CHECK_F( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) ); ip += frameHeaderSize; remainingSize -= frameHeaderSize; } /* Loop on each block */ while (1) { size_t decodedSize; blockProperties_t blockProperties; size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties); if (ZSTD_isError(cBlockSize)) return cBlockSize; ip += ZSTD_blockHeaderSize; remainingSize -= ZSTD_blockHeaderSize; if (cBlockSize > remainingSize) return ERROR(srcSize_wrong); switch(blockProperties.blockType) { case bt_compressed: decodedSize = ZSTD_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize, /* frame */ 1); break; case bt_raw : decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize); break; case bt_rle : decodedSize = ZSTD_generateNxBytes(op, oend-op, *ip, blockProperties.origSize); break; case bt_reserved : default: return ERROR(corruption_detected); } if (ZSTD_isError(decodedSize)) return decodedSize; if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, op, decodedSize); op += decodedSize; ip += cBlockSize; remainingSize -= cBlockSize; if (blockProperties.lastBlock) break; } if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) { if ((U64)(op-ostart) != dctx->fParams.frameContentSize) { return ERROR(corruption_detected); } } if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */ U32 const checkCalc = (U32)XXH64_digest(&dctx->xxhState); U32 checkRead; if (remainingSize<4) return ERROR(checksum_wrong); checkRead = MEM_readLE32(ip); if (checkRead != checkCalc) return ERROR(checksum_wrong); ip += 4; remainingSize -= 4; } /* Allow caller to get size read */ *srcPtr = ip; *srcSizePtr = remainingSize; return op-ostart; } static const void* ZSTD_DDictDictContent(const ZSTD_DDict* ddict); static size_t ZSTD_DDictDictSize(const ZSTD_DDict* ddict); static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict, size_t dictSize, const ZSTD_DDict* ddict) { void* const dststart = dst; assert(dict==NULL || ddict==NULL); /* either dict or ddict set, not both */ if (ddict) { dict = ZSTD_DDictDictContent(ddict); dictSize = ZSTD_DDictDictSize(ddict); } while (srcSize >= ZSTD_frameHeaderSize_prefix) { U32 magicNumber; #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) if (ZSTD_isLegacy(src, srcSize)) { size_t decodedSize; size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy(src, srcSize); if (ZSTD_isError(frameSize)) return frameSize; /* legacy support is not compatible with static dctx */ if (dctx->staticSize) return ERROR(memory_allocation); decodedSize = ZSTD_decompressLegacy(dst, dstCapacity, src, frameSize, dict, dictSize); dst = (BYTE*)dst + decodedSize; dstCapacity -= decodedSize; src = (const BYTE*)src + frameSize; srcSize -= frameSize; continue; } #endif magicNumber = MEM_readLE32(src); DEBUGLOG(4, "reading magic number %08X (expecting %08X)", (U32)magicNumber, (U32)ZSTD_MAGICNUMBER); if (magicNumber != ZSTD_MAGICNUMBER) { if ((magicNumber & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) { size_t skippableSize; if (srcSize < ZSTD_skippableHeaderSize) return ERROR(srcSize_wrong); skippableSize = MEM_readLE32((const BYTE*)src + ZSTD_frameIdSize) + ZSTD_skippableHeaderSize; if (srcSize < skippableSize) return ERROR(srcSize_wrong); src = (const BYTE *)src + skippableSize; srcSize -= skippableSize; continue; } return ERROR(prefix_unknown); } if (ddict) { /* we were called from ZSTD_decompress_usingDDict */ CHECK_F(ZSTD_decompressBegin_usingDDict(dctx, ddict)); } else { /* this will initialize correctly with no dict if dict == NULL, so * use this in all cases but ddict */ CHECK_F(ZSTD_decompressBegin_usingDict(dctx, dict, dictSize)); } ZSTD_checkContinuity(dctx, dst); { const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity, &src, &srcSize); if (ZSTD_isError(res)) return res; /* no need to bound check, ZSTD_decompressFrame already has */ dst = (BYTE*)dst + res; dstCapacity -= res; } } /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */ if (srcSize) return ERROR(srcSize_wrong); /* input not entirely consumed */ return (BYTE*)dst - (BYTE*)dststart; } size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict, size_t dictSize) { return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL); } size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) { return ZSTD_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0); } size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize) { #if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1) size_t regenSize; ZSTD_DCtx* const dctx = ZSTD_createDCtx(); if (dctx==NULL) return ERROR(memory_allocation); regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize); ZSTD_freeDCtx(dctx); return regenSize; #else /* stack mode */ ZSTD_DCtx dctx; return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize); #endif } /*-************************************** * Advanced Streaming Decompression API * Bufferless and synchronous ****************************************/ size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; } ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) { switch(dctx->stage) { default: /* should not happen */ assert(0); case ZSTDds_getFrameHeaderSize: case ZSTDds_decodeFrameHeader: return ZSTDnit_frameHeader; case ZSTDds_decodeBlockHeader: return ZSTDnit_blockHeader; case ZSTDds_decompressBlock: return ZSTDnit_block; case ZSTDds_decompressLastBlock: return ZSTDnit_lastBlock; case ZSTDds_checkChecksum: return ZSTDnit_checksum; case ZSTDds_decodeSkippableHeader: case ZSTDds_skipFrame: return ZSTDnit_skippableFrame; } } static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; } /** ZSTD_decompressContinue() : * srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress()) * @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity) * or an error code, which can be tested using ZSTD_isError() */ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) { DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (U32)srcSize); /* Sanity check */ if (srcSize != dctx->expected) return ERROR(srcSize_wrong); /* not allowed */ if (dstCapacity) ZSTD_checkContinuity(dctx, dst); switch (dctx->stage) { case ZSTDds_getFrameHeaderSize : assert(src != NULL); if (dctx->format == ZSTD_f_zstd1) { /* allows header */ assert(srcSize >= ZSTD_frameIdSize); /* to read skippable magic number */ if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */ memcpy(dctx->headerBuffer, src, srcSize); dctx->expected = ZSTD_skippableHeaderSize - srcSize; /* remaining to load to get full skippable frame header */ dctx->stage = ZSTDds_decodeSkippableHeader; return 0; } } dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format); if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize; memcpy(dctx->headerBuffer, src, srcSize); dctx->expected = dctx->headerSize - srcSize; dctx->stage = ZSTDds_decodeFrameHeader; return 0; case ZSTDds_decodeFrameHeader: assert(src != NULL); memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, srcSize); CHECK_F(ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize)); dctx->expected = ZSTD_blockHeaderSize; dctx->stage = ZSTDds_decodeBlockHeader; return 0; case ZSTDds_decodeBlockHeader: { blockProperties_t bp; size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp); if (ZSTD_isError(cBlockSize)) return cBlockSize; dctx->expected = cBlockSize; dctx->bType = bp.blockType; dctx->rleSize = bp.origSize; if (cBlockSize) { dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock; return 0; } /* empty block */ if (bp.lastBlock) { if (dctx->fParams.checksumFlag) { dctx->expected = 4; dctx->stage = ZSTDds_checkChecksum; } else { dctx->expected = 0; /* end of frame */ dctx->stage = ZSTDds_getFrameHeaderSize; } } else { dctx->expected = ZSTD_blockHeaderSize; /* jump to next header */ dctx->stage = ZSTDds_decodeBlockHeader; } return 0; } case ZSTDds_decompressLastBlock: case ZSTDds_decompressBlock: DEBUGLOG(5, "ZSTD_decompressContinue: case ZSTDds_decompressBlock"); { size_t rSize; switch(dctx->bType) { case bt_compressed: DEBUGLOG(5, "ZSTD_decompressContinue: case bt_compressed"); rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 1); break; case bt_raw : rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize); break; case bt_rle : rSize = ZSTD_setRleBlock(dst, dstCapacity, src, srcSize, dctx->rleSize); break; case bt_reserved : /* should never happen */ default: return ERROR(corruption_detected); } if (ZSTD_isError(rSize)) return rSize; DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (U32)rSize); dctx->decodedSize += rSize; if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, dst, rSize); if (dctx->stage == ZSTDds_decompressLastBlock) { /* end of frame */ DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (U32)dctx->decodedSize); if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) { if (dctx->decodedSize != dctx->fParams.frameContentSize) { return ERROR(corruption_detected); } } if (dctx->fParams.checksumFlag) { /* another round for frame checksum */ dctx->expected = 4; dctx->stage = ZSTDds_checkChecksum; } else { dctx->expected = 0; /* ends here */ dctx->stage = ZSTDds_getFrameHeaderSize; } } else { dctx->stage = ZSTDds_decodeBlockHeader; dctx->expected = ZSTD_blockHeaderSize; dctx->previousDstEnd = (char*)dst + rSize; } return rSize; } case ZSTDds_checkChecksum: assert(srcSize == 4); /* guaranteed by dctx->expected */ { U32 const h32 = (U32)XXH64_digest(&dctx->xxhState); U32 const check32 = MEM_readLE32(src); DEBUGLOG(4, "ZSTD_decompressContinue: checksum : calculated %08X :: %08X read", h32, check32); if (check32 != h32) return ERROR(checksum_wrong); dctx->expected = 0; dctx->stage = ZSTDds_getFrameHeaderSize; return 0; } case ZSTDds_decodeSkippableHeader: assert(src != NULL); assert(srcSize <= ZSTD_skippableHeaderSize); memcpy(dctx->headerBuffer + (ZSTD_skippableHeaderSize - srcSize), src, srcSize); /* complete skippable header */ dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_frameIdSize); /* note : dctx->expected can grow seriously large, beyond local buffer size */ dctx->stage = ZSTDds_skipFrame; return 0; case ZSTDds_skipFrame: dctx->expected = 0; dctx->stage = ZSTDds_getFrameHeaderSize; return 0; default: return ERROR(GENERIC); /* impossible */ } } static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) { dctx->dictEnd = dctx->previousDstEnd; dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base)); dctx->base = dict; dctx->previousDstEnd = (const char*)dict + dictSize; return 0; } /* ZSTD_loadEntropy() : * dict : must point at beginning of a valid zstd dictionary * @return : size of entropy tables read */ static size_t ZSTD_loadEntropy(ZSTD_entropyDTables_t* entropy, const void* const dict, size_t const dictSize) { const BYTE* dictPtr = (const BYTE*)dict; const BYTE* const dictEnd = dictPtr + dictSize; if (dictSize <= 8) return ERROR(dictionary_corrupted); dictPtr += 8; /* skip header = magic + dictID */ { size_t const hSize = HUF_readDTableX4_wksp( entropy->hufTable, dictPtr, dictEnd - dictPtr, entropy->workspace, sizeof(entropy->workspace)); if (HUF_isError(hSize)) return ERROR(dictionary_corrupted); dictPtr += hSize; } { short offcodeNCount[MaxOff+1]; U32 offcodeMaxValue = MaxOff, offcodeLog; size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr); if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted); if (offcodeMaxValue > MaxOff) return ERROR(dictionary_corrupted); if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted); ZSTD_buildFSETable(entropy->OFTable, offcodeNCount, offcodeMaxValue, OF_base, OF_bits, offcodeLog); dictPtr += offcodeHeaderSize; } { short matchlengthNCount[MaxML+1]; unsigned matchlengthMaxValue = MaxML, matchlengthLog; size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr); if (FSE_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted); if (matchlengthMaxValue > MaxML) return ERROR(dictionary_corrupted); if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted); ZSTD_buildFSETable(entropy->MLTable, matchlengthNCount, matchlengthMaxValue, ML_base, ML_bits, matchlengthLog); dictPtr += matchlengthHeaderSize; } { short litlengthNCount[MaxLL+1]; unsigned litlengthMaxValue = MaxLL, litlengthLog; size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr); if (FSE_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted); if (litlengthMaxValue > MaxLL) return ERROR(dictionary_corrupted); if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted); ZSTD_buildFSETable(entropy->LLTable, litlengthNCount, litlengthMaxValue, LL_base, LL_bits, litlengthLog); dictPtr += litlengthHeaderSize; } if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted); { int i; size_t const dictContentSize = (size_t)(dictEnd - (dictPtr+12)); for (i=0; i<3; i++) { U32 const rep = MEM_readLE32(dictPtr); dictPtr += 4; if (rep==0 || rep >= dictContentSize) return ERROR(dictionary_corrupted); entropy->rep[i] = rep; } } return dictPtr - (const BYTE*)dict; } static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) { if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize); { U32 const magic = MEM_readLE32(dict); if (magic != ZSTD_MAGIC_DICTIONARY) { return ZSTD_refDictContent(dctx, dict, dictSize); /* pure content mode */ } } dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_frameIdSize); /* load entropy tables */ { size_t const eSize = ZSTD_loadEntropy(&dctx->entropy, dict, dictSize); if (ZSTD_isError(eSize)) return ERROR(dictionary_corrupted); dict = (const char*)dict + eSize; dictSize -= eSize; } dctx->litEntropy = dctx->fseEntropy = 1; /* reference dictionary content */ return ZSTD_refDictContent(dctx, dict, dictSize); } /* Note : this function cannot fail */ size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx) { assert(dctx != NULL); dctx->expected = ZSTD_startingInputLength(dctx->format); /* dctx->format must be properly set */ dctx->stage = ZSTDds_getFrameHeaderSize; dctx->decodedSize = 0; dctx->previousDstEnd = NULL; dctx->base = NULL; dctx->vBase = NULL; dctx->dictEnd = NULL; dctx->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001); /* cover both little and big endian */ dctx->litEntropy = dctx->fseEntropy = 0; dctx->dictID = 0; ZSTD_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue)); memcpy(dctx->entropy.rep, repStartValue, sizeof(repStartValue)); /* initial repcodes */ dctx->LLTptr = dctx->entropy.LLTable; dctx->MLTptr = dctx->entropy.MLTable; dctx->OFTptr = dctx->entropy.OFTable; dctx->HUFptr = dctx->entropy.hufTable; return 0; } size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) { CHECK_F( ZSTD_decompressBegin(dctx) ); if (dict && dictSize) CHECK_E(ZSTD_decompress_insertDictionary(dctx, dict, dictSize), dictionary_corrupted); return 0; } /* ====== ZSTD_DDict ====== */ struct ZSTD_DDict_s { void* dictBuffer; const void* dictContent; size_t dictSize; ZSTD_entropyDTables_t entropy; U32 dictID; U32 entropyPresent; ZSTD_customMem cMem; }; /* typedef'd to ZSTD_DDict within "zstd.h" */ static const void* ZSTD_DDictDictContent(const ZSTD_DDict* ddict) { return ddict->dictContent; } static size_t ZSTD_DDictDictSize(const ZSTD_DDict* ddict) { return ddict->dictSize; } size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dstDCtx, const ZSTD_DDict* ddict) { CHECK_F( ZSTD_decompressBegin(dstDCtx) ); if (ddict) { /* support begin on NULL */ dstDCtx->dictID = ddict->dictID; dstDCtx->base = ddict->dictContent; dstDCtx->vBase = ddict->dictContent; dstDCtx->dictEnd = (const BYTE*)ddict->dictContent + ddict->dictSize; dstDCtx->previousDstEnd = dstDCtx->dictEnd; if (ddict->entropyPresent) { dstDCtx->litEntropy = 1; dstDCtx->fseEntropy = 1; dstDCtx->LLTptr = ddict->entropy.LLTable; dstDCtx->MLTptr = ddict->entropy.MLTable; dstDCtx->OFTptr = ddict->entropy.OFTable; dstDCtx->HUFptr = ddict->entropy.hufTable; dstDCtx->entropy.rep[0] = ddict->entropy.rep[0]; dstDCtx->entropy.rep[1] = ddict->entropy.rep[1]; dstDCtx->entropy.rep[2] = ddict->entropy.rep[2]; } else { dstDCtx->litEntropy = 0; dstDCtx->fseEntropy = 0; } } return 0; } static size_t ZSTD_loadEntropy_inDDict(ZSTD_DDict* ddict, ZSTD_dictContentType_e dictContentType) { ddict->dictID = 0; ddict->entropyPresent = 0; if (dictContentType == ZSTD_dct_rawContent) return 0; if (ddict->dictSize < 8) { if (dictContentType == ZSTD_dct_fullDict) return ERROR(dictionary_corrupted); /* only accept specified dictionaries */ return 0; /* pure content mode */ } { U32 const magic = MEM_readLE32(ddict->dictContent); if (magic != ZSTD_MAGIC_DICTIONARY) { if (dictContentType == ZSTD_dct_fullDict) return ERROR(dictionary_corrupted); /* only accept specified dictionaries */ return 0; /* pure content mode */ } } ddict->dictID = MEM_readLE32((const char*)ddict->dictContent + ZSTD_frameIdSize); /* load entropy tables */ CHECK_E( ZSTD_loadEntropy(&ddict->entropy, ddict->dictContent, ddict->dictSize), dictionary_corrupted ); ddict->entropyPresent = 1; return 0; } static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType) { if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dict) || (!dictSize)) { ddict->dictBuffer = NULL; ddict->dictContent = dict; } else { void* const internalBuffer = ZSTD_malloc(dictSize, ddict->cMem); ddict->dictBuffer = internalBuffer; ddict->dictContent = internalBuffer; if (!internalBuffer) return ERROR(memory_allocation); memcpy(internalBuffer, dict, dictSize); } ddict->dictSize = dictSize; ddict->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001); /* cover both little and big endian */ /* parse dictionary content */ CHECK_F( ZSTD_loadEntropy_inDDict(ddict, dictContentType) ); return 0; } ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_customMem customMem) { if (!customMem.customAlloc ^ !customMem.customFree) return NULL; { ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_malloc(sizeof(ZSTD_DDict), customMem); if (!ddict) return NULL; ddict->cMem = customMem; if (ZSTD_isError( ZSTD_initDDict_internal(ddict, dict, dictSize, dictLoadMethod, dictContentType) )) { ZSTD_freeDDict(ddict); return NULL; } return ddict; } } /*! ZSTD_createDDict() : * Create a digested dictionary, to start decompression without startup delay. * `dict` content is copied inside DDict. * Consequently, `dict` can be released after `ZSTD_DDict` creation */ ZSTD_DDict* ZSTD_createDDict(const void* dict, size_t dictSize) { ZSTD_customMem const allocator = { NULL, NULL, NULL }; return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator); } /*! ZSTD_createDDict_byReference() : * Create a digested dictionary, to start decompression without startup delay. * Dictionary content is simply referenced, it will be accessed during decompression. * Warning : dictBuffer must outlive DDict (DDict must be freed before dictBuffer) */ ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize) { ZSTD_customMem const allocator = { NULL, NULL, NULL }; return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator); } const ZSTD_DDict* ZSTD_initStaticDDict( void* workspace, size_t workspaceSize, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType) { size_t const neededSpace = sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize); ZSTD_DDict* const ddict = (ZSTD_DDict*)workspace; assert(workspace != NULL); assert(dict != NULL); if ((size_t)workspace & 7) return NULL; /* 8-aligned */ if (workspaceSize < neededSpace) return NULL; if (dictLoadMethod == ZSTD_dlm_byCopy) { memcpy(ddict+1, dict, dictSize); /* local copy */ dict = ddict+1; } if (ZSTD_isError( ZSTD_initDDict_internal(ddict, dict, dictSize, ZSTD_dlm_byRef, dictContentType) )) return NULL; return ddict; } size_t ZSTD_freeDDict(ZSTD_DDict* ddict) { if (ddict==NULL) return 0; /* support free on NULL */ { ZSTD_customMem const cMem = ddict->cMem; ZSTD_free(ddict->dictBuffer, cMem); ZSTD_free(ddict, cMem); return 0; } } /*! ZSTD_estimateDDictSize() : * Estimate amount of memory that will be needed to create a dictionary for decompression. * Note : dictionary created by reference using ZSTD_dlm_byRef are smaller */ size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod) { return sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize); } size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict) { if (ddict==NULL) return 0; /* support sizeof on NULL */ return sizeof(*ddict) + (ddict->dictBuffer ? ddict->dictSize : 0) ; } /*! ZSTD_getDictID_fromDict() : * Provides the dictID stored within dictionary. * if @return == 0, the dictionary is not conformant with Zstandard specification. * It can still be loaded, but as a content-only dictionary. */ unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize) { if (dictSize < 8) return 0; if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) return 0; return MEM_readLE32((const char*)dict + ZSTD_frameIdSize); } /*! ZSTD_getDictID_fromDDict() : * Provides the dictID of the dictionary loaded into `ddict`. * If @return == 0, the dictionary is not conformant to Zstandard specification, or empty. * Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */ unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict) { if (ddict==NULL) return 0; return ZSTD_getDictID_fromDict(ddict->dictContent, ddict->dictSize); } /*! ZSTD_getDictID_fromFrame() : * Provides the dictID required to decompresse frame stored within `src`. * If @return == 0, the dictID could not be decoded. * This could for one of the following reasons : * - The frame does not require a dictionary (most common case). * - The frame was built with dictID intentionally removed. * Needed dictionary is a hidden information. * Note : this use case also happens when using a non-conformant dictionary. * - `srcSize` is too small, and as a result, frame header could not be decoded. * Note : possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`. * - This is not a Zstandard frame. * When identifying the exact failure cause, it's possible to use * ZSTD_getFrameHeader(), which will provide a more precise error code. */ unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize) { ZSTD_frameHeader zfp = { 0, 0, 0, ZSTD_frame, 0, 0, 0 }; size_t const hError = ZSTD_getFrameHeader(&zfp, src, srcSize); if (ZSTD_isError(hError)) return 0; return zfp.dictID; } /*! ZSTD_decompress_usingDDict() : * Decompression using a pre-digested Dictionary * Use dictionary without significant overhead. */ size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const ZSTD_DDict* ddict) { /* pass content and size in case legacy frames are encountered */ return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, NULL, 0, ddict); } /*===================================== * Streaming decompression *====================================*/ ZSTD_DStream* ZSTD_createDStream(void) { DEBUGLOG(3, "ZSTD_createDStream"); return ZSTD_createDStream_advanced(ZSTD_defaultCMem); } ZSTD_DStream* ZSTD_initStaticDStream(void *workspace, size_t workspaceSize) { return ZSTD_initStaticDCtx(workspace, workspaceSize); } ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem) { return ZSTD_createDCtx_advanced(customMem); } size_t ZSTD_freeDStream(ZSTD_DStream* zds) { return ZSTD_freeDCtx(zds); } /* *** Initialization *** */ size_t ZSTD_DStreamInSize(void) { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; } size_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; } size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType) { if (dctx->streamStage != zdss_init) return ERROR(stage_wrong); ZSTD_freeDDict(dctx->ddictLocal); if (dict && dictSize >= 8) { dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, dctx->customMem); if (dctx->ddictLocal == NULL) return ERROR(memory_allocation); } else { dctx->ddictLocal = NULL; } dctx->ddict = dctx->ddictLocal; return 0; } size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) { return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto); } size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) { return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto); } size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType) { return ZSTD_DCtx_loadDictionary_advanced(dctx, prefix, prefixSize, ZSTD_dlm_byRef, dictContentType); } size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize) { return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent); } /* ZSTD_initDStream_usingDict() : * return : expected size, aka ZSTD_frameHeaderSize_prefix. * this function cannot fail */ size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize) { DEBUGLOG(4, "ZSTD_initDStream_usingDict"); zds->streamStage = zdss_init; CHECK_F( ZSTD_DCtx_loadDictionary(zds, dict, dictSize) ); return ZSTD_frameHeaderSize_prefix; } /* note : this variant can't fail */ size_t ZSTD_initDStream(ZSTD_DStream* zds) { DEBUGLOG(4, "ZSTD_initDStream"); return ZSTD_initDStream_usingDict(zds, NULL, 0); } size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict) { if (dctx->streamStage != zdss_init) return ERROR(stage_wrong); dctx->ddict = ddict; return 0; } /* ZSTD_initDStream_usingDDict() : * ddict will just be referenced, and must outlive decompression session * this function cannot fail */ size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict) { size_t const initResult = ZSTD_initDStream(dctx); dctx->ddict = ddict; return initResult; } /* ZSTD_resetDStream() : * return : expected size, aka ZSTD_frameHeaderSize_prefix. * this function cannot fail */ size_t ZSTD_resetDStream(ZSTD_DStream* dctx) { DEBUGLOG(4, "ZSTD_resetDStream"); dctx->streamStage = zdss_loadHeader; dctx->lhSize = dctx->inPos = dctx->outStart = dctx->outEnd = 0; dctx->legacyVersion = 0; dctx->hostageByte = 0; return ZSTD_frameHeaderSize_prefix; } size_t ZSTD_setDStreamParameter(ZSTD_DStream* dctx, ZSTD_DStreamParameter_e paramType, unsigned paramValue) { if (dctx->streamStage != zdss_init) return ERROR(stage_wrong); switch(paramType) { default : return ERROR(parameter_unsupported); case DStream_p_maxWindowSize : DEBUGLOG(4, "setting maxWindowSize = %u KB", paramValue >> 10); dctx->maxWindowSize = paramValue ? paramValue : (U32)(-1); break; } return 0; } size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize) { if (dctx->streamStage != zdss_init) return ERROR(stage_wrong); dctx->maxWindowSize = maxWindowSize; return 0; } size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format) { DEBUGLOG(4, "ZSTD_DCtx_setFormat : %u", (unsigned)format); if (dctx->streamStage != zdss_init) return ERROR(stage_wrong); dctx->format = format; return 0; } size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx) { return ZSTD_sizeof_DCtx(dctx); } size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize) { size_t const blockSize = (size_t) MIN(windowSize, ZSTD_BLOCKSIZE_MAX); unsigned long long const neededRBSize = windowSize + blockSize + (WILDCOPY_OVERLENGTH * 2); unsigned long long const neededSize = MIN(frameContentSize, neededRBSize); size_t const minRBSize = (size_t) neededSize; if ((unsigned long long)minRBSize != neededSize) return ERROR(frameParameter_windowTooLarge); return minRBSize; } size_t ZSTD_estimateDStreamSize(size_t windowSize) { size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX); size_t const inBuffSize = blockSize; /* no block can be larger */ size_t const outBuffSize = ZSTD_decodingBufferSize_min(windowSize, ZSTD_CONTENTSIZE_UNKNOWN); return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize; } size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize) { U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX; /* note : should be user-selectable */ ZSTD_frameHeader zfh; size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize); if (ZSTD_isError(err)) return err; if (err>0) return ERROR(srcSize_wrong); if (zfh.windowSize > windowSizeMax) return ERROR(frameParameter_windowTooLarge); return ZSTD_estimateDStreamSize((size_t)zfh.windowSize); } /* ***** Decompression ***** */ MEM_STATIC size_t ZSTD_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize) { size_t const length = MIN(dstCapacity, srcSize); memcpy(dst, src, length); return length; } size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input) { const char* const istart = (const char*)(input->src) + input->pos; const char* const iend = (const char*)(input->src) + input->size; const char* ip = istart; char* const ostart = (char*)(output->dst) + output->pos; char* const oend = (char*)(output->dst) + output->size; char* op = ostart; U32 someMoreWork = 1; DEBUGLOG(5, "ZSTD_decompressStream"); if (input->pos > input->size) { /* forbidden */ DEBUGLOG(5, "in: pos: %u vs size: %u", (U32)input->pos, (U32)input->size); return ERROR(srcSize_wrong); } if (output->pos > output->size) { /* forbidden */ DEBUGLOG(5, "out: pos: %u vs size: %u", (U32)output->pos, (U32)output->size); return ERROR(dstSize_tooSmall); } DEBUGLOG(5, "input size : %u", (U32)(input->size - input->pos)); while (someMoreWork) { switch(zds->streamStage) { case zdss_init : DEBUGLOG(5, "stage zdss_init => transparent reset "); ZSTD_resetDStream(zds); /* transparent reset on starting decoding a new frame */ /* fall-through */ case zdss_loadHeader : DEBUGLOG(5, "stage zdss_loadHeader (srcSize : %u)", (U32)(iend - ip)); #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) if (zds->legacyVersion) { /* legacy support is incompatible with static dctx */ if (zds->staticSize) return ERROR(memory_allocation); { size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, zds->legacyVersion, output, input); if (hint==0) zds->streamStage = zdss_init; return hint; } } #endif { size_t const hSize = ZSTD_getFrameHeader_internal(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format); DEBUGLOG(5, "header size : %u", (U32)hSize); if (ZSTD_isError(hSize)) { #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) U32 const legacyVersion = ZSTD_isLegacy(istart, iend-istart); if (legacyVersion) { const void* const dict = zds->ddict ? zds->ddict->dictContent : NULL; size_t const dictSize = zds->ddict ? zds->ddict->dictSize : 0; DEBUGLOG(5, "ZSTD_decompressStream: detected legacy version v0.%u", legacyVersion); /* legacy support is incompatible with static dctx */ if (zds->staticSize) return ERROR(memory_allocation); CHECK_F(ZSTD_initLegacyStream(&zds->legacyContext, zds->previousLegacyVersion, legacyVersion, dict, dictSize)); zds->legacyVersion = zds->previousLegacyVersion = legacyVersion; { size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input); if (hint==0) zds->streamStage = zdss_init; /* or stay in stage zdss_loadHeader */ return hint; } } #endif return hSize; /* error */ } if (hSize != 0) { /* need more input */ size_t const toLoad = hSize - zds->lhSize; /* if hSize!=0, hSize > zds->lhSize */ size_t const remainingInput = (size_t)(iend-ip); assert(iend >= ip); if (toLoad > remainingInput) { /* not enough input to load full header */ if (remainingInput > 0) { memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput); zds->lhSize += remainingInput; } input->pos = input->size; return (MAX(ZSTD_frameHeaderSize_min, hSize) - zds->lhSize) + ZSTD_blockHeaderSize; /* remaining header bytes + next block header */ } assert(ip != NULL); memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad; break; } } /* check for single-pass mode opportunity */ if (zds->fParams.frameContentSize && zds->fParams.windowSize /* skippable frame if == 0 */ && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) { size_t const cSize = ZSTD_findFrameCompressedSize(istart, iend-istart); if (cSize <= (size_t)(iend-istart)) { /* shortcut : using single-pass mode */ size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, oend-op, istart, cSize, zds->ddict); if (ZSTD_isError(decompressedSize)) return decompressedSize; DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()") ip = istart + cSize; op += decompressedSize; zds->expected = 0; zds->streamStage = zdss_init; someMoreWork = 0; break; } } /* Consume header (see ZSTDds_decodeFrameHeader) */ DEBUGLOG(4, "Consume header"); CHECK_F(ZSTD_decompressBegin_usingDDict(zds, zds->ddict)); if ((MEM_readLE32(zds->headerBuffer) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */ zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_frameIdSize); zds->stage = ZSTDds_skipFrame; } else { CHECK_F(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize)); zds->expected = ZSTD_blockHeaderSize; zds->stage = ZSTDds_decodeBlockHeader; } /* control buffer memory usage */ DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)", (U32)(zds->fParams.windowSize >>10), (U32)(zds->maxWindowSize >> 10) ); zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN); if (zds->fParams.windowSize > zds->maxWindowSize) return ERROR(frameParameter_windowTooLarge); /* Adapt buffer sizes to frame header instructions */ { size_t const neededInBuffSize = MAX(zds->fParams.blockSizeMax, 4 /* frame checksum */); size_t const neededOutBuffSize = ZSTD_decodingBufferSize_min(zds->fParams.windowSize, zds->fParams.frameContentSize); if ((zds->inBuffSize < neededInBuffSize) || (zds->outBuffSize < neededOutBuffSize)) { size_t const bufferSize = neededInBuffSize + neededOutBuffSize; DEBUGLOG(4, "inBuff : from %u to %u", (U32)zds->inBuffSize, (U32)neededInBuffSize); DEBUGLOG(4, "outBuff : from %u to %u", (U32)zds->outBuffSize, (U32)neededOutBuffSize); if (zds->staticSize) { /* static DCtx */ DEBUGLOG(4, "staticSize : %u", (U32)zds->staticSize); assert(zds->staticSize >= sizeof(ZSTD_DCtx)); /* controlled at init */ if (bufferSize > zds->staticSize - sizeof(ZSTD_DCtx)) return ERROR(memory_allocation); } else { ZSTD_free(zds->inBuff, zds->customMem); zds->inBuffSize = 0; zds->outBuffSize = 0; zds->inBuff = (char*)ZSTD_malloc(bufferSize, zds->customMem); if (zds->inBuff == NULL) return ERROR(memory_allocation); } zds->inBuffSize = neededInBuffSize; zds->outBuff = zds->inBuff + zds->inBuffSize; zds->outBuffSize = neededOutBuffSize; } } zds->streamStage = zdss_read; /* fall-through */ case zdss_read: DEBUGLOG(5, "stage zdss_read"); { size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds); DEBUGLOG(5, "neededInSize = %u", (U32)neededInSize); if (neededInSize==0) { /* end of frame */ zds->streamStage = zdss_init; someMoreWork = 0; break; } if ((size_t)(iend-ip) >= neededInSize) { /* decode directly from src */ int const isSkipFrame = ZSTD_isSkipFrame(zds); size_t const decodedSize = ZSTD_decompressContinue(zds, zds->outBuff + zds->outStart, (isSkipFrame ? 0 : zds->outBuffSize - zds->outStart), ip, neededInSize); if (ZSTD_isError(decodedSize)) return decodedSize; ip += neededInSize; if (!decodedSize && !isSkipFrame) break; /* this was just a header */ zds->outEnd = zds->outStart + decodedSize; zds->streamStage = zdss_flush; break; } } if (ip==iend) { someMoreWork = 0; break; } /* no more input */ zds->streamStage = zdss_load; /* fall-through */ case zdss_load: { size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds); size_t const toLoad = neededInSize - zds->inPos; int const isSkipFrame = ZSTD_isSkipFrame(zds); size_t loadedSize; if (isSkipFrame) { loadedSize = MIN(toLoad, (size_t)(iend-ip)); } else { if (toLoad > zds->inBuffSize - zds->inPos) return ERROR(corruption_detected); /* should never happen */ loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, iend-ip); } ip += loadedSize; zds->inPos += loadedSize; if (loadedSize < toLoad) { someMoreWork = 0; break; } /* not enough input, wait for more */ /* decode loaded input */ { size_t const decodedSize = ZSTD_decompressContinue(zds, zds->outBuff + zds->outStart, zds->outBuffSize - zds->outStart, zds->inBuff, neededInSize); if (ZSTD_isError(decodedSize)) return decodedSize; zds->inPos = 0; /* input is consumed */ if (!decodedSize && !isSkipFrame) { zds->streamStage = zdss_read; break; } /* this was just a header */ zds->outEnd = zds->outStart + decodedSize; } } zds->streamStage = zdss_flush; /* fall-through */ case zdss_flush: { size_t const toFlushSize = zds->outEnd - zds->outStart; size_t const flushedSize = ZSTD_limitCopy(op, oend-op, zds->outBuff + zds->outStart, toFlushSize); op += flushedSize; zds->outStart += flushedSize; if (flushedSize == toFlushSize) { /* flush completed */ zds->streamStage = zdss_read; if ( (zds->outBuffSize < zds->fParams.frameContentSize) && (zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize) ) { DEBUGLOG(5, "restart filling outBuff from beginning (left:%i, needed:%u)", (int)(zds->outBuffSize - zds->outStart), (U32)zds->fParams.blockSizeMax); zds->outStart = zds->outEnd = 0; } break; } } /* cannot complete flush */ someMoreWork = 0; break; default: return ERROR(GENERIC); /* impossible */ } } /* result */ input->pos += (size_t)(ip-istart); output->pos += (size_t)(op-ostart); { size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds); if (!nextSrcSizeHint) { /* frame fully decoded */ if (zds->outEnd == zds->outStart) { /* output fully flushed */ if (zds->hostageByte) { if (input->pos >= input->size) { /* can't release hostage (not present) */ zds->streamStage = zdss_read; return 1; } input->pos++; /* release hostage */ } /* zds->hostageByte */ return 0; } /* zds->outEnd == zds->outStart */ if (!zds->hostageByte) { /* output not fully flushed; keep last byte as hostage; will be released when all output is flushed */ input->pos--; /* note : pos > 0, otherwise, impossible to finish reading last block */ zds->hostageByte=1; } return 1; } /* nextSrcSizeHint==0 */ nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds) == ZSTDnit_block); /* preload header of next block */ assert(zds->inPos <= nextSrcSizeHint); nextSrcSizeHint -= zds->inPos; /* part already loaded*/ return nextSrcSizeHint; } } size_t ZSTD_decompress_generic(ZSTD_DCtx* dctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input) { return ZSTD_decompressStream(dctx, output, input); } size_t ZSTD_decompress_generic_simpleArgs ( ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, size_t* dstPos, const void* src, size_t srcSize, size_t* srcPos) { ZSTD_outBuffer output = { dst, dstCapacity, *dstPos }; ZSTD_inBuffer input = { src, srcSize, *srcPos }; /* ZSTD_compress_generic() will check validity of dstPos and srcPos */ size_t const cErr = ZSTD_decompress_generic(dctx, &output, &input); *dstPos = output.pos; *srcPos = input.pos; return cErr; } void ZSTD_DCtx_reset(ZSTD_DCtx* dctx) { (void)ZSTD_initDStream(dctx); dctx->format = ZSTD_f_zstd1; dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT; } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_double_fast.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #include "zstd_compress_internal.h" #include "zstd_double_fast.h" void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, void const* end) { U32* const hashLarge = ms->hashTable; U32 const hBitsL = cParams->hashLog; U32 const mls = cParams->searchLength; U32* const hashSmall = ms->chainTable; U32 const hBitsS = cParams->chainLog; const BYTE* const base = ms->window.base; const BYTE* ip = base + ms->nextToUpdate; const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE; const U32 fastHashFillStep = 3; /* Always insert every fastHashFillStep position into the hash tables. * Insert the other positions into the large hash table if their entry * is empty. */ for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep) { U32 const current = (U32)(ip - base); U32 i; for (i = 0; i < fastHashFillStep; ++i) { size_t const smHash = ZSTD_hashPtr(ip + i, hBitsS, mls); size_t const lgHash = ZSTD_hashPtr(ip + i, hBitsL, 8); if (i == 0) hashSmall[smHash] = current + i; if (i == 0 || hashLarge[lgHash] == 0) hashLarge[lgHash] = current + i; } } } FORCE_INLINE_TEMPLATE size_t ZSTD_compressBlock_doubleFast_generic( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize, U32 const mls /* template */) { U32* const hashLong = ms->hashTable; const U32 hBitsL = cParams->hashLog; U32* const hashSmall = ms->chainTable; const U32 hBitsS = cParams->chainLog; const BYTE* const base = ms->window.base; const BYTE* const istart = (const BYTE*)src; const BYTE* ip = istart; const BYTE* anchor = istart; const U32 lowestIndex = ms->window.dictLimit; const BYTE* const lowest = base + lowestIndex; const BYTE* const iend = istart + srcSize; const BYTE* const ilimit = iend - HASH_READ_SIZE; U32 offset_1=rep[0], offset_2=rep[1]; U32 offsetSaved = 0; /* init */ ip += (ip==lowest); { U32 const maxRep = (U32)(ip-lowest); if (offset_2 > maxRep) offsetSaved = offset_2, offset_2 = 0; if (offset_1 > maxRep) offsetSaved = offset_1, offset_1 = 0; } /* Main Search Loop */ while (ip < ilimit) { /* < instead of <=, because repcode check at (ip+1) */ size_t mLength; size_t const h2 = ZSTD_hashPtr(ip, hBitsL, 8); size_t const h = ZSTD_hashPtr(ip, hBitsS, mls); U32 const current = (U32)(ip-base); U32 const matchIndexL = hashLong[h2]; U32 const matchIndexS = hashSmall[h]; const BYTE* matchLong = base + matchIndexL; const BYTE* match = base + matchIndexS; hashLong[h2] = hashSmall[h] = current; /* update hash tables */ assert(offset_1 <= current); /* supposed guaranteed by construction */ if ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1))) { /* favor repcode */ mLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4; ip++; ZSTD_storeSeq(seqStore, ip-anchor, anchor, 0, mLength-MINMATCH); } else { U32 offset; if ( (matchIndexL > lowestIndex) && (MEM_read64(matchLong) == MEM_read64(ip)) ) { mLength = ZSTD_count(ip+8, matchLong+8, iend) + 8; offset = (U32)(ip-matchLong); while (((ip>anchor) & (matchLong>lowest)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; } /* catch up */ } else if ( (matchIndexS > lowestIndex) && (MEM_read32(match) == MEM_read32(ip)) ) { size_t const hl3 = ZSTD_hashPtr(ip+1, hBitsL, 8); U32 const matchIndexL3 = hashLong[hl3]; const BYTE* matchL3 = base + matchIndexL3; hashLong[hl3] = current + 1; if ( (matchIndexL3 > lowestIndex) && (MEM_read64(matchL3) == MEM_read64(ip+1)) ) { mLength = ZSTD_count(ip+9, matchL3+8, iend) + 8; ip++; offset = (U32)(ip-matchL3); while (((ip>anchor) & (matchL3>lowest)) && (ip[-1] == matchL3[-1])) { ip--; matchL3--; mLength++; } /* catch up */ } else { mLength = ZSTD_count(ip+4, match+4, iend) + 4; offset = (U32)(ip-match); while (((ip>anchor) & (match>lowest)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */ } } else { ip += ((ip-anchor) >> kSearchStrength) + 1; continue; } offset_2 = offset_1; offset_1 = offset; ZSTD_storeSeq(seqStore, ip-anchor, anchor, offset + ZSTD_REP_MOVE, mLength-MINMATCH); } /* match found */ ip += mLength; anchor = ip; if (ip <= ilimit) { /* Fill Table */ hashLong[ZSTD_hashPtr(base+current+2, hBitsL, 8)] = hashSmall[ZSTD_hashPtr(base+current+2, hBitsS, mls)] = current+2; /* here because current+2 could be > iend-8 */ hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = hashSmall[ZSTD_hashPtr(ip-2, hBitsS, mls)] = (U32)(ip-2-base); /* check immediate repcode */ while ( (ip <= ilimit) && ( (offset_2>0) & (MEM_read32(ip) == MEM_read32(ip - offset_2)) )) { /* store sequence */ size_t const rLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4; { U32 const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff; } /* swap offset_2 <=> offset_1 */ hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = (U32)(ip-base); hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = (U32)(ip-base); ZSTD_storeSeq(seqStore, 0, anchor, 0, rLength-MINMATCH); ip += rLength; anchor = ip; continue; /* faster when present ... (?) */ } } } /* save reps for next block */ rep[0] = offset_1 ? offset_1 : offsetSaved; rep[1] = offset_2 ? offset_2 : offsetSaved; /* Return the last literals size */ return iend - anchor; } size_t ZSTD_compressBlock_doubleFast( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { const U32 mls = cParams->searchLength; switch(mls) { default: /* includes case 3 */ case 4 : return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, cParams, src, srcSize, 4); case 5 : return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, cParams, src, srcSize, 5); case 6 : return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, cParams, src, srcSize, 6); case 7 : return ZSTD_compressBlock_doubleFast_generic(ms, seqStore, rep, cParams, src, srcSize, 7); } } static size_t ZSTD_compressBlock_doubleFast_extDict_generic( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize, U32 const mls /* template */) { U32* const hashLong = ms->hashTable; U32 const hBitsL = cParams->hashLog; U32* const hashSmall = ms->chainTable; U32 const hBitsS = cParams->chainLog; const BYTE* const base = ms->window.base; const BYTE* const dictBase = ms->window.dictBase; const BYTE* const istart = (const BYTE*)src; const BYTE* ip = istart; const BYTE* anchor = istart; const U32 lowestIndex = ms->window.lowLimit; const BYTE* const dictStart = dictBase + lowestIndex; const U32 dictLimit = ms->window.dictLimit; const BYTE* const lowPrefixPtr = base + dictLimit; const BYTE* const dictEnd = dictBase + dictLimit; const BYTE* const iend = istart + srcSize; const BYTE* const ilimit = iend - 8; U32 offset_1=rep[0], offset_2=rep[1]; /* Search Loop */ while (ip < ilimit) { /* < instead of <=, because (ip+1) */ const size_t hSmall = ZSTD_hashPtr(ip, hBitsS, mls); const U32 matchIndex = hashSmall[hSmall]; const BYTE* matchBase = matchIndex < dictLimit ? dictBase : base; const BYTE* match = matchBase + matchIndex; const size_t hLong = ZSTD_hashPtr(ip, hBitsL, 8); const U32 matchLongIndex = hashLong[hLong]; const BYTE* matchLongBase = matchLongIndex < dictLimit ? dictBase : base; const BYTE* matchLong = matchLongBase + matchLongIndex; const U32 current = (U32)(ip-base); const U32 repIndex = current + 1 - offset_1; /* offset_1 expected <= current +1 */ const BYTE* repBase = repIndex < dictLimit ? dictBase : base; const BYTE* repMatch = repBase + repIndex; size_t mLength; hashSmall[hSmall] = hashLong[hLong] = current; /* update hash table */ if ( (((U32)((dictLimit-1) - repIndex) >= 3) /* intentional underflow */ & (repIndex > lowestIndex)) && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) { const BYTE* repMatchEnd = repIndex < dictLimit ? dictEnd : iend; mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, lowPrefixPtr) + 4; ip++; ZSTD_storeSeq(seqStore, ip-anchor, anchor, 0, mLength-MINMATCH); } else { if ((matchLongIndex > lowestIndex) && (MEM_read64(matchLong) == MEM_read64(ip))) { const BYTE* matchEnd = matchLongIndex < dictLimit ? dictEnd : iend; const BYTE* lowMatchPtr = matchLongIndex < dictLimit ? dictStart : lowPrefixPtr; U32 offset; mLength = ZSTD_count_2segments(ip+8, matchLong+8, iend, matchEnd, lowPrefixPtr) + 8; offset = current - matchLongIndex; while (((ip>anchor) & (matchLong>lowMatchPtr)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; } /* catch up */ offset_2 = offset_1; offset_1 = offset; ZSTD_storeSeq(seqStore, ip-anchor, anchor, offset + ZSTD_REP_MOVE, mLength-MINMATCH); } else if ((matchIndex > lowestIndex) && (MEM_read32(match) == MEM_read32(ip))) { size_t const h3 = ZSTD_hashPtr(ip+1, hBitsL, 8); U32 const matchIndex3 = hashLong[h3]; const BYTE* const match3Base = matchIndex3 < dictLimit ? dictBase : base; const BYTE* match3 = match3Base + matchIndex3; U32 offset; hashLong[h3] = current + 1; if ( (matchIndex3 > lowestIndex) && (MEM_read64(match3) == MEM_read64(ip+1)) ) { const BYTE* matchEnd = matchIndex3 < dictLimit ? dictEnd : iend; const BYTE* lowMatchPtr = matchIndex3 < dictLimit ? dictStart : lowPrefixPtr; mLength = ZSTD_count_2segments(ip+9, match3+8, iend, matchEnd, lowPrefixPtr) + 8; ip++; offset = current+1 - matchIndex3; while (((ip>anchor) & (match3>lowMatchPtr)) && (ip[-1] == match3[-1])) { ip--; match3--; mLength++; } /* catch up */ } else { const BYTE* matchEnd = matchIndex < dictLimit ? dictEnd : iend; const BYTE* lowMatchPtr = matchIndex < dictLimit ? dictStart : lowPrefixPtr; mLength = ZSTD_count_2segments(ip+4, match+4, iend, matchEnd, lowPrefixPtr) + 4; offset = current - matchIndex; while (((ip>anchor) & (match>lowMatchPtr)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */ } offset_2 = offset_1; offset_1 = offset; ZSTD_storeSeq(seqStore, ip-anchor, anchor, offset + ZSTD_REP_MOVE, mLength-MINMATCH); } else { ip += ((ip-anchor) >> kSearchStrength) + 1; continue; } } /* found a match : store it */ ip += mLength; anchor = ip; if (ip <= ilimit) { /* Fill Table */ hashSmall[ZSTD_hashPtr(base+current+2, hBitsS, mls)] = current+2; hashLong[ZSTD_hashPtr(base+current+2, hBitsL, 8)] = current+2; hashSmall[ZSTD_hashPtr(ip-2, hBitsS, mls)] = (U32)(ip-2-base); hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base); /* check immediate repcode */ while (ip <= ilimit) { U32 const current2 = (U32)(ip-base); U32 const repIndex2 = current2 - offset_2; const BYTE* repMatch2 = repIndex2 < dictLimit ? dictBase + repIndex2 : base + repIndex2; if ( (((U32)((dictLimit-1) - repIndex2) >= 3) & (repIndex2 > lowestIndex)) /* intentional overflow */ && (MEM_read32(repMatch2) == MEM_read32(ip)) ) { const BYTE* const repEnd2 = repIndex2 < dictLimit ? dictEnd : iend; size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, lowPrefixPtr) + 4; U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; /* swap offset_2 <=> offset_1 */ ZSTD_storeSeq(seqStore, 0, anchor, 0, repLength2-MINMATCH); hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2; hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2; ip += repLength2; anchor = ip; continue; } break; } } } /* save reps for next block */ rep[0] = offset_1; rep[1] = offset_2; /* Return the last literals size */ return iend - anchor; } size_t ZSTD_compressBlock_doubleFast_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { U32 const mls = cParams->searchLength; switch(mls) { default: /* includes case 3 */ case 4 : return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, cParams, src, srcSize, 4); case 5 : return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, cParams, src, srcSize, 5); case 6 : return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, cParams, src, srcSize, 6); case 7 : return ZSTD_compressBlock_doubleFast_extDict_generic(ms, seqStore, rep, cParams, src, srcSize, 7); } } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_double_fast.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef ZSTD_DOUBLE_FAST_H #define ZSTD_DOUBLE_FAST_H #if defined (__cplusplus) extern "C" { #endif #include "mem.h" /* U32 */ #include "zstd_compress_internal.h" /* ZSTD_CCtx, size_t */ void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, void const* end); size_t ZSTD_compressBlock_doubleFast( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_doubleFast_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); #if defined (__cplusplus) } #endif #endif /* ZSTD_DOUBLE_FAST_H */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_errors.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef ZSTD_ERRORS_H_398273423 #define ZSTD_ERRORS_H_398273423 #if defined (__cplusplus) extern "C" { #endif /*===== dependency =====*/ #include /* size_t */ /* ===== ZSTDERRORLIB_API : control library symbols visibility ===== */ #ifndef ZSTDERRORLIB_VISIBILITY # if defined(__GNUC__) && (__GNUC__ >= 4) # define ZSTDERRORLIB_VISIBILITY __attribute__ ((visibility ("default"))) # else # define ZSTDERRORLIB_VISIBILITY # endif #endif #if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1) # define ZSTDERRORLIB_API __declspec(dllexport) ZSTDERRORLIB_VISIBILITY #elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1) # define ZSTDERRORLIB_API __declspec(dllimport) ZSTDERRORLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/ #else # define ZSTDERRORLIB_API ZSTDERRORLIB_VISIBILITY #endif /*-********************************************* * Error codes list *-********************************************* * Error codes _values_ are pinned down since v1.3.1 only. * Therefore, don't rely on values if you may link to any version < v1.3.1. * * Only values < 100 are considered stable. * * note 1 : this API shall be used with static linking only. * dynamic linking is not yet officially supported. * note 2 : Prefer relying on the enum than on its value whenever possible * This is the only supported way to use the error list < v1.3.1 * note 3 : ZSTD_isError() is always correct, whatever the library version. **********************************************/ typedef enum { ZSTD_error_no_error = 0, ZSTD_error_GENERIC = 1, ZSTD_error_prefix_unknown = 10, ZSTD_error_version_unsupported = 12, ZSTD_error_frameParameter_unsupported = 14, ZSTD_error_frameParameter_windowTooLarge = 16, ZSTD_error_corruption_detected = 20, ZSTD_error_checksum_wrong = 22, ZSTD_error_dictionary_corrupted = 30, ZSTD_error_dictionary_wrong = 32, ZSTD_error_dictionaryCreation_failed = 34, ZSTD_error_parameter_unsupported = 40, ZSTD_error_parameter_outOfBound = 42, ZSTD_error_tableLog_tooLarge = 44, ZSTD_error_maxSymbolValue_tooLarge = 46, ZSTD_error_maxSymbolValue_tooSmall = 48, ZSTD_error_stage_wrong = 60, ZSTD_error_init_missing = 62, ZSTD_error_memory_allocation = 64, ZSTD_error_workSpace_tooSmall= 66, ZSTD_error_dstSize_tooSmall = 70, ZSTD_error_srcSize_wrong = 72, /* following error codes are __NOT STABLE__, they can be removed or changed in future versions */ ZSTD_error_frameIndex_tooLarge = 100, ZSTD_error_seekableIO = 102, ZSTD_error_maxCode = 120 /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */ } ZSTD_ErrorCode; /*! ZSTD_getErrorCode() : convert a `size_t` function result into a `ZSTD_ErrorCode` enum type, which can be used to compare with enum list published above */ ZSTDERRORLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult); ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code); /**< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument */ #if defined (__cplusplus) } #endif #endif /* ZSTD_ERRORS_H_398273423 */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_fast.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #include "zstd_compress_internal.h" #include "zstd_fast.h" void ZSTD_fillHashTable(ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, void const* end) { U32* const hashTable = ms->hashTable; U32 const hBits = cParams->hashLog; U32 const mls = cParams->searchLength; const BYTE* const base = ms->window.base; const BYTE* ip = base + ms->nextToUpdate; const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE; const U32 fastHashFillStep = 3; /* Always insert every fastHashFillStep position into the hash table. * Insert the other positions if their hash entry is empty. */ for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep) { U32 const current = (U32)(ip - base); U32 i; for (i = 0; i < fastHashFillStep; ++i) { size_t const hash = ZSTD_hashPtr(ip + i, hBits, mls); if (i == 0 || hashTable[hash] == 0) hashTable[hash] = current + i; } } } FORCE_INLINE_TEMPLATE size_t ZSTD_compressBlock_fast_generic( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], void const* src, size_t srcSize, U32 const hlog, U32 const stepSize, U32 const mls) { U32* const hashTable = ms->hashTable; const BYTE* const base = ms->window.base; const BYTE* const istart = (const BYTE*)src; const BYTE* ip = istart; const BYTE* anchor = istart; const U32 lowestIndex = ms->window.dictLimit; const BYTE* const lowest = base + lowestIndex; const BYTE* const iend = istart + srcSize; const BYTE* const ilimit = iend - HASH_READ_SIZE; U32 offset_1=rep[0], offset_2=rep[1]; U32 offsetSaved = 0; /* init */ ip += (ip==lowest); { U32 const maxRep = (U32)(ip-lowest); if (offset_2 > maxRep) offsetSaved = offset_2, offset_2 = 0; if (offset_1 > maxRep) offsetSaved = offset_1, offset_1 = 0; } /* Main Search Loop */ while (ip < ilimit) { /* < instead of <=, because repcode check at (ip+1) */ size_t mLength; size_t const h = ZSTD_hashPtr(ip, hlog, mls); U32 const current = (U32)(ip-base); U32 const matchIndex = hashTable[h]; const BYTE* match = base + matchIndex; hashTable[h] = current; /* update hash table */ if ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1))) { mLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4; ip++; ZSTD_storeSeq(seqStore, ip-anchor, anchor, 0, mLength-MINMATCH); } else { if ( (matchIndex <= lowestIndex) || (MEM_read32(match) != MEM_read32(ip)) ) { assert(stepSize >= 1); ip += ((ip-anchor) >> kSearchStrength) + stepSize; continue; } mLength = ZSTD_count(ip+4, match+4, iend) + 4; { U32 const offset = (U32)(ip-match); while (((ip>anchor) & (match>lowest)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */ offset_2 = offset_1; offset_1 = offset; ZSTD_storeSeq(seqStore, ip-anchor, anchor, offset + ZSTD_REP_MOVE, mLength-MINMATCH); } } /* match found */ ip += mLength; anchor = ip; if (ip <= ilimit) { /* Fill Table */ hashTable[ZSTD_hashPtr(base+current+2, hlog, mls)] = current+2; /* here because current+2 could be > iend-8 */ hashTable[ZSTD_hashPtr(ip-2, hlog, mls)] = (U32)(ip-2-base); /* check immediate repcode */ while ( (ip <= ilimit) && ( (offset_2>0) & (MEM_read32(ip) == MEM_read32(ip - offset_2)) )) { /* store sequence */ size_t const rLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4; { U32 const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff; } /* swap offset_2 <=> offset_1 */ hashTable[ZSTD_hashPtr(ip, hlog, mls)] = (U32)(ip-base); ZSTD_storeSeq(seqStore, 0, anchor, 0, rLength-MINMATCH); ip += rLength; anchor = ip; continue; /* faster when present ... (?) */ } } } /* save reps for next block */ rep[0] = offset_1 ? offset_1 : offsetSaved; rep[1] = offset_2 ? offset_2 : offsetSaved; /* Return the last literals size */ return iend - anchor; } size_t ZSTD_compressBlock_fast( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { U32 const hlog = cParams->hashLog; U32 const mls = cParams->searchLength; U32 const stepSize = cParams->targetLength; switch(mls) { default: /* includes case 3 */ case 4 : return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, hlog, stepSize, 4); case 5 : return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, hlog, stepSize, 5); case 6 : return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, hlog, stepSize, 6); case 7 : return ZSTD_compressBlock_fast_generic(ms, seqStore, rep, src, srcSize, hlog, stepSize, 7); } } static size_t ZSTD_compressBlock_fast_extDict_generic( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], void const* src, size_t srcSize, U32 const hlog, U32 const stepSize, U32 const mls) { U32* hashTable = ms->hashTable; const BYTE* const base = ms->window.base; const BYTE* const dictBase = ms->window.dictBase; const BYTE* const istart = (const BYTE*)src; const BYTE* ip = istart; const BYTE* anchor = istart; const U32 lowestIndex = ms->window.lowLimit; const BYTE* const dictStart = dictBase + lowestIndex; const U32 dictLimit = ms->window.dictLimit; const BYTE* const lowPrefixPtr = base + dictLimit; const BYTE* const dictEnd = dictBase + dictLimit; const BYTE* const iend = istart + srcSize; const BYTE* const ilimit = iend - 8; U32 offset_1=rep[0], offset_2=rep[1]; /* Search Loop */ while (ip < ilimit) { /* < instead of <=, because (ip+1) */ const size_t h = ZSTD_hashPtr(ip, hlog, mls); const U32 matchIndex = hashTable[h]; const BYTE* matchBase = matchIndex < dictLimit ? dictBase : base; const BYTE* match = matchBase + matchIndex; const U32 current = (U32)(ip-base); const U32 repIndex = current + 1 - offset_1; /* offset_1 expected <= current +1 */ const BYTE* repBase = repIndex < dictLimit ? dictBase : base; const BYTE* repMatch = repBase + repIndex; size_t mLength; hashTable[h] = current; /* update hash table */ if ( (((U32)((dictLimit-1) - repIndex) >= 3) /* intentional underflow */ & (repIndex > lowestIndex)) && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) { const BYTE* repMatchEnd = repIndex < dictLimit ? dictEnd : iend; mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, lowPrefixPtr) + 4; ip++; ZSTD_storeSeq(seqStore, ip-anchor, anchor, 0, mLength-MINMATCH); } else { if ( (matchIndex < lowestIndex) || (MEM_read32(match) != MEM_read32(ip)) ) { assert(stepSize >= 1); ip += ((ip-anchor) >> kSearchStrength) + stepSize; continue; } { const BYTE* matchEnd = matchIndex < dictLimit ? dictEnd : iend; const BYTE* lowMatchPtr = matchIndex < dictLimit ? dictStart : lowPrefixPtr; U32 offset; mLength = ZSTD_count_2segments(ip+4, match+4, iend, matchEnd, lowPrefixPtr) + 4; while (((ip>anchor) & (match>lowMatchPtr)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */ offset = current - matchIndex; offset_2 = offset_1; offset_1 = offset; ZSTD_storeSeq(seqStore, ip-anchor, anchor, offset + ZSTD_REP_MOVE, mLength-MINMATCH); } } /* found a match : store it */ ip += mLength; anchor = ip; if (ip <= ilimit) { /* Fill Table */ hashTable[ZSTD_hashPtr(base+current+2, hlog, mls)] = current+2; hashTable[ZSTD_hashPtr(ip-2, hlog, mls)] = (U32)(ip-2-base); /* check immediate repcode */ while (ip <= ilimit) { U32 const current2 = (U32)(ip-base); U32 const repIndex2 = current2 - offset_2; const BYTE* repMatch2 = repIndex2 < dictLimit ? dictBase + repIndex2 : base + repIndex2; if ( (((U32)((dictLimit-1) - repIndex2) >= 3) & (repIndex2 > lowestIndex)) /* intentional overflow */ && (MEM_read32(repMatch2) == MEM_read32(ip)) ) { const BYTE* const repEnd2 = repIndex2 < dictLimit ? dictEnd : iend; size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, lowPrefixPtr) + 4; U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; /* swap offset_2 <=> offset_1 */ ZSTD_storeSeq(seqStore, 0, anchor, 0, repLength2-MINMATCH); hashTable[ZSTD_hashPtr(ip, hlog, mls)] = current2; ip += repLength2; anchor = ip; continue; } break; } } } /* save reps for next block */ rep[0] = offset_1; rep[1] = offset_2; /* Return the last literals size */ return iend - anchor; } size_t ZSTD_compressBlock_fast_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { U32 const hlog = cParams->hashLog; U32 const mls = cParams->searchLength; U32 const stepSize = cParams->targetLength; switch(mls) { default: /* includes case 3 */ case 4 : return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, hlog, stepSize, 4); case 5 : return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, hlog, stepSize, 5); case 6 : return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, hlog, stepSize, 6); case 7 : return ZSTD_compressBlock_fast_extDict_generic(ms, seqStore, rep, src, srcSize, hlog, stepSize, 7); } } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_fast.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef ZSTD_FAST_H #define ZSTD_FAST_H #if defined (__cplusplus) extern "C" { #endif #include "mem.h" /* U32 */ #include "zstd_compress_internal.h" void ZSTD_fillHashTable(ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, void const* end); size_t ZSTD_compressBlock_fast( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_fast_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); #if defined (__cplusplus) } #endif #endif /* ZSTD_FAST_H */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_internal.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef ZSTD_CCOMMON_H_MODULE #define ZSTD_CCOMMON_H_MODULE /* this module contains definitions which must be identical * across compression, decompression and dictBuilder. * It also contains a few functions useful to at least 2 of them * and which benefit from being inlined */ /*-************************************* * Dependencies ***************************************/ #include "compiler.h" #include "mem.h" #include "error_private.h" #define ZSTD_STATIC_LINKING_ONLY #include "zstd.h" #define FSE_STATIC_LINKING_ONLY #include "fse.h" #define HUF_STATIC_LINKING_ONLY #include "huf.h" #ifndef XXH_STATIC_LINKING_ONLY # define XXH_STATIC_LINKING_ONLY /* XXH64_state_t */ #endif #include "xxhash.h" /* XXH_reset, update, digest */ #if defined (__cplusplus) extern "C" { #endif /*-************************************* * Debug ***************************************/ #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=1) # include #else # ifndef assert # define assert(condition) ((void)0) # endif #endif #define ZSTD_STATIC_ASSERT(c) { enum { ZSTD_static_assert = 1/(int)(!!(c)) }; } #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=2) # include extern int g_debuglog_enable; /* recommended values for ZSTD_DEBUG display levels : * 1 : no display, enables assert() only * 2 : reserved for currently active debug path * 3 : events once per object lifetime (CCtx, CDict, etc.) * 4 : events once per frame * 5 : events once per block * 6 : events once per sequence (*very* verbose) */ # define RAWLOG(l, ...) { \ if ((g_debuglog_enable) & (l<=ZSTD_DEBUG)) { \ fprintf(stderr, __VA_ARGS__); \ } } # define DEBUGLOG(l, ...) { \ if ((g_debuglog_enable) & (l<=ZSTD_DEBUG)) { \ fprintf(stderr, __FILE__ ": " __VA_ARGS__); \ fprintf(stderr, " \n"); \ } } #else # define RAWLOG(l, ...) {} /* disabled */ # define DEBUGLOG(l, ...) {} /* disabled */ #endif /*-************************************* * shared macros ***************************************/ #undef MIN #undef MAX #define MIN(a,b) ((a)<(b) ? (a) : (b)) #define MAX(a,b) ((a)>(b) ? (a) : (b)) #define CHECK_F(f) { size_t const errcod = f; if (ERR_isError(errcod)) return errcod; } /* check and Forward error code */ #define CHECK_E(f, e) { size_t const errcod = f; if (ERR_isError(errcod)) return ERROR(e); } /* check and send Error code */ /*-************************************* * Common constants ***************************************/ #define ZSTD_OPT_NUM (1<<12) #define ZSTD_REP_NUM 3 /* number of repcodes */ #define ZSTD_REP_MOVE (ZSTD_REP_NUM-1) static const U32 repStartValue[ZSTD_REP_NUM] = { 1, 4, 8 }; #define KB *(1 <<10) #define MB *(1 <<20) #define GB *(1U<<30) #define BIT7 128 #define BIT6 64 #define BIT5 32 #define BIT4 16 #define BIT1 2 #define BIT0 1 #define ZSTD_WINDOWLOG_ABSOLUTEMIN 10 #define ZSTD_WINDOWLOG_DEFAULTMAX 27 /* Default maximum allowed window log */ static const size_t ZSTD_fcs_fieldSize[4] = { 0, 2, 4, 8 }; static const size_t ZSTD_did_fieldSize[4] = { 0, 1, 2, 4 }; #define ZSTD_FRAMEIDSIZE 4 static const size_t ZSTD_frameIdSize = ZSTD_FRAMEIDSIZE; /* magic number size */ #define ZSTD_BLOCKHEADERSIZE 3 /* C standard doesn't allow `static const` variable to be init using another `static const` variable */ static const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE; typedef enum { bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e; #define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */ #define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */) /* for a non-null block */ #define HufLog 12 typedef enum { set_basic, set_rle, set_compressed, set_repeat } symbolEncodingType_e; #define LONGNBSEQ 0x7F00 #define MINMATCH 3 #define Litbits 8 #define MaxLit ((1<= 3) /* GCC Intrinsic */ return 31 - __builtin_clz(val); # else /* Software version */ static const U32 DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; U32 v = val; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; return DeBruijnClz[(v * 0x07C4ACDDU) >> 27]; # endif } } /* ZSTD_invalidateRepCodes() : * ensures next compression will not use repcodes from previous block. * Note : only works with regular variant; * do not use with extDict variant ! */ void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx); /* zstdmt, adaptive_compression (shouldn't get this definition from here) */ typedef struct { blockType_e blockType; U32 lastBlock; U32 origSize; } blockProperties_t; /*! ZSTD_getcBlockSize() : * Provides the size of compressed block from block header `src` */ /* Used by: decompress, fullbench (does not get its definition from here) */ size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr); #if defined (__cplusplus) } #endif #endif /* ZSTD_CCOMMON_H_MODULE */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_lazy.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #include "zstd_compress_internal.h" #include "zstd_lazy.h" /*-************************************* * Binary Tree search ***************************************/ void ZSTD_updateDUBT( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip, const BYTE* iend, U32 mls) { U32* const hashTable = ms->hashTable; U32 const hashLog = cParams->hashLog; U32* const bt = ms->chainTable; U32 const btLog = cParams->chainLog - 1; U32 const btMask = (1 << btLog) - 1; const BYTE* const base = ms->window.base; U32 const target = (U32)(ip - base); U32 idx = ms->nextToUpdate; if (idx != target) DEBUGLOG(7, "ZSTD_updateDUBT, from %u to %u (dictLimit:%u)", idx, target, ms->window.dictLimit); assert(ip + 8 <= iend); /* condition for ZSTD_hashPtr */ (void)iend; assert(idx >= ms->window.dictLimit); /* condition for valid base+idx */ for ( ; idx < target ; idx++) { size_t const h = ZSTD_hashPtr(base + idx, hashLog, mls); /* assumption : ip + 8 <= iend */ U32 const matchIndex = hashTable[h]; U32* const nextCandidatePtr = bt + 2*(idx&btMask); U32* const sortMarkPtr = nextCandidatePtr + 1; DEBUGLOG(8, "ZSTD_updateDUBT: insert %u", idx); hashTable[h] = idx; /* Update Hash Table */ *nextCandidatePtr = matchIndex; /* update BT like a chain */ *sortMarkPtr = ZSTD_DUBT_UNSORTED_MARK; } ms->nextToUpdate = target; } /** ZSTD_insertDUBT1() : * sort one already inserted but unsorted position * assumption : current >= btlow == (current - btmask) * doesn't fail */ static void ZSTD_insertDUBT1( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, U32 current, const BYTE* inputEnd, U32 nbCompares, U32 btLow, int extDict) { U32* const bt = ms->chainTable; U32 const btLog = cParams->chainLog - 1; U32 const btMask = (1 << btLog) - 1; size_t commonLengthSmaller=0, commonLengthLarger=0; const BYTE* const base = ms->window.base; const BYTE* const dictBase = ms->window.dictBase; const U32 dictLimit = ms->window.dictLimit; const BYTE* const ip = (current>=dictLimit) ? base + current : dictBase + current; const BYTE* const iend = (current>=dictLimit) ? inputEnd : dictBase + dictLimit; const BYTE* const dictEnd = dictBase + dictLimit; const BYTE* const prefixStart = base + dictLimit; const BYTE* match; U32* smallerPtr = bt + 2*(current&btMask); U32* largerPtr = smallerPtr + 1; U32 matchIndex = *smallerPtr; U32 dummy32; /* to be nullified at the end */ U32 const windowLow = ms->window.lowLimit; DEBUGLOG(8, "ZSTD_insertDUBT1(%u) (dictLimit=%u, lowLimit=%u)", current, dictLimit, windowLow); assert(current >= btLow); assert(ip < iend); /* condition for ZSTD_count */ while (nbCompares-- && (matchIndex > windowLow)) { U32* const nextPtr = bt + 2*(matchIndex & btMask); size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */ assert(matchIndex < current); if ( (!extDict) || (matchIndex+matchLength >= dictLimit) /* both in current segment*/ || (current < dictLimit) /* both in extDict */) { const BYTE* const mBase = !extDict || ((matchIndex+matchLength) >= dictLimit) ? base : dictBase; assert( (matchIndex+matchLength >= dictLimit) /* might be wrong if extDict is incorrectly set to 0 */ || (current < dictLimit) ); match = mBase + matchIndex; matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend); } else { match = dictBase + matchIndex; matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart); if (matchIndex+matchLength >= dictLimit) match = base + matchIndex; /* to prepare for next usage of match[matchLength] */ } DEBUGLOG(8, "ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes ", current, matchIndex, (U32)matchLength); if (ip+matchLength == iend) { /* equal : no way to know if inf or sup */ break; /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */ } if (match[matchLength] < ip[matchLength]) { /* necessarily within buffer */ /* match is smaller than current */ *smallerPtr = matchIndex; /* update smaller idx */ commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */ if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop searching */ DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is smaller : next => %u", matchIndex, btLow, nextPtr[1]); smallerPtr = nextPtr+1; /* new "candidate" => larger than match, which was smaller than target */ matchIndex = nextPtr[1]; /* new matchIndex, larger than previous and closer to current */ } else { /* match is larger than current */ *largerPtr = matchIndex; commonLengthLarger = matchLength; if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop searching */ DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is larger => %u", matchIndex, btLow, nextPtr[0]); largerPtr = nextPtr; matchIndex = nextPtr[0]; } } *smallerPtr = *largerPtr = 0; } static size_t ZSTD_DUBT_findBestMatch ( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* const ip, const BYTE* const iend, size_t* offsetPtr, U32 const mls, U32 const extDict) { U32* const hashTable = ms->hashTable; U32 const hashLog = cParams->hashLog; size_t const h = ZSTD_hashPtr(ip, hashLog, mls); U32 matchIndex = hashTable[h]; const BYTE* const base = ms->window.base; U32 const current = (U32)(ip-base); U32 const windowLow = ms->window.lowLimit; U32* const bt = ms->chainTable; U32 const btLog = cParams->chainLog - 1; U32 const btMask = (1 << btLog) - 1; U32 const btLow = (btMask >= current) ? 0 : current - btMask; U32 const unsortLimit = MAX(btLow, windowLow); U32* nextCandidate = bt + 2*(matchIndex&btMask); U32* unsortedMark = bt + 2*(matchIndex&btMask) + 1; U32 nbCompares = 1U << cParams->searchLog; U32 nbCandidates = nbCompares; U32 previousCandidate = 0; DEBUGLOG(7, "ZSTD_DUBT_findBestMatch (%u) ", current); assert(ip <= iend-8); /* required for h calculation */ /* reach end of unsorted candidates list */ while ( (matchIndex > unsortLimit) && (*unsortedMark == ZSTD_DUBT_UNSORTED_MARK) && (nbCandidates > 1) ) { DEBUGLOG(8, "ZSTD_DUBT_findBestMatch: candidate %u is unsorted", matchIndex); *unsortedMark = previousCandidate; previousCandidate = matchIndex; matchIndex = *nextCandidate; nextCandidate = bt + 2*(matchIndex&btMask); unsortedMark = bt + 2*(matchIndex&btMask) + 1; nbCandidates --; } if ( (matchIndex > unsortLimit) && (*unsortedMark==ZSTD_DUBT_UNSORTED_MARK) ) { DEBUGLOG(7, "ZSTD_DUBT_findBestMatch: nullify last unsorted candidate %u", matchIndex); *nextCandidate = *unsortedMark = 0; /* nullify next candidate if it's still unsorted (note : simplification, detrimental to compression ratio, beneficial for speed) */ } /* batch sort stacked candidates */ matchIndex = previousCandidate; while (matchIndex) { /* will end on matchIndex == 0 */ U32* const nextCandidateIdxPtr = bt + 2*(matchIndex&btMask) + 1; U32 const nextCandidateIdx = *nextCandidateIdxPtr; ZSTD_insertDUBT1(ms, cParams, matchIndex, iend, nbCandidates, unsortLimit, extDict); matchIndex = nextCandidateIdx; nbCandidates++; } /* find longest match */ { size_t commonLengthSmaller=0, commonLengthLarger=0; const BYTE* const dictBase = ms->window.dictBase; const U32 dictLimit = ms->window.dictLimit; const BYTE* const dictEnd = dictBase + dictLimit; const BYTE* const prefixStart = base + dictLimit; U32* smallerPtr = bt + 2*(current&btMask); U32* largerPtr = bt + 2*(current&btMask) + 1; U32 matchEndIdx = current+8+1; U32 dummy32; /* to be nullified at the end */ size_t bestLength = 0; matchIndex = hashTable[h]; hashTable[h] = current; /* Update Hash Table */ while (nbCompares-- && (matchIndex > windowLow)) { U32* const nextPtr = bt + 2*(matchIndex & btMask); size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */ const BYTE* match; if ((!extDict) || (matchIndex+matchLength >= dictLimit)) { match = base + matchIndex; matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend); } else { match = dictBase + matchIndex; matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart); if (matchIndex+matchLength >= dictLimit) match = base + matchIndex; /* to prepare for next usage of match[matchLength] */ } if (matchLength > bestLength) { if (matchLength > matchEndIdx - matchIndex) matchEndIdx = matchIndex + (U32)matchLength; if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(current-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) ) bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex; if (ip+matchLength == iend) { /* equal : no way to know if inf or sup */ break; /* drop, to guarantee consistency (miss a little bit of compression) */ } } if (match[matchLength] < ip[matchLength]) { /* match is smaller than current */ *smallerPtr = matchIndex; /* update smaller idx */ commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */ if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop the search */ smallerPtr = nextPtr+1; /* new "smaller" => larger of match */ matchIndex = nextPtr[1]; /* new matchIndex larger than previous (closer to current) */ } else { /* match is larger than current */ *largerPtr = matchIndex; commonLengthLarger = matchLength; if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */ largerPtr = nextPtr; matchIndex = nextPtr[0]; } } *smallerPtr = *largerPtr = 0; assert(matchEndIdx > current+8); /* ensure nextToUpdate is increased */ ms->nextToUpdate = matchEndIdx - 8; /* skip repetitive patterns */ if (bestLength >= MINMATCH) { U32 const mIndex = current - ((U32)*offsetPtr - ZSTD_REP_MOVE); (void)mIndex; DEBUGLOG(8, "ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)", current, (U32)bestLength, (U32)*offsetPtr, mIndex); } return bestLength; } } /** ZSTD_BtFindBestMatch() : Tree updater, providing best match */ static size_t ZSTD_BtFindBestMatch ( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* const ip, const BYTE* const iLimit, size_t* offsetPtr, const U32 mls /* template */) { DEBUGLOG(7, "ZSTD_BtFindBestMatch"); if (ip < ms->window.base + ms->nextToUpdate) return 0; /* skipped area */ ZSTD_updateDUBT(ms, cParams, ip, iLimit, mls); return ZSTD_DUBT_findBestMatch(ms, cParams, ip, iLimit, offsetPtr, mls, 0); } static size_t ZSTD_BtFindBestMatch_selectMLS ( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip, const BYTE* const iLimit, size_t* offsetPtr) { switch(cParams->searchLength) { default : /* includes case 3 */ case 4 : return ZSTD_BtFindBestMatch(ms, cParams, ip, iLimit, offsetPtr, 4); case 5 : return ZSTD_BtFindBestMatch(ms, cParams, ip, iLimit, offsetPtr, 5); case 7 : case 6 : return ZSTD_BtFindBestMatch(ms, cParams, ip, iLimit, offsetPtr, 6); } } /** Tree updater, providing best match */ static size_t ZSTD_BtFindBestMatch_extDict ( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* const ip, const BYTE* const iLimit, size_t* offsetPtr, const U32 mls) { DEBUGLOG(7, "ZSTD_BtFindBestMatch_extDict"); if (ip < ms->window.base + ms->nextToUpdate) return 0; /* skipped area */ ZSTD_updateDUBT(ms, cParams, ip, iLimit, mls); return ZSTD_DUBT_findBestMatch(ms, cParams, ip, iLimit, offsetPtr, mls, 1); } static size_t ZSTD_BtFindBestMatch_selectMLS_extDict ( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip, const BYTE* const iLimit, size_t* offsetPtr) { switch(cParams->searchLength) { default : /* includes case 3 */ case 4 : return ZSTD_BtFindBestMatch_extDict(ms, cParams, ip, iLimit, offsetPtr, 4); case 5 : return ZSTD_BtFindBestMatch_extDict(ms, cParams, ip, iLimit, offsetPtr, 5); case 7 : case 6 : return ZSTD_BtFindBestMatch_extDict(ms, cParams, ip, iLimit, offsetPtr, 6); } } /* ********************************* * Hash Chain ***********************************/ #define NEXT_IN_CHAIN(d, mask) chainTable[(d) & mask] /* Update chains up to ip (excluded) Assumption : always within prefix (i.e. not within extDict) */ static U32 ZSTD_insertAndFindFirstIndex_internal( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip, U32 const mls) { U32* const hashTable = ms->hashTable; const U32 hashLog = cParams->hashLog; U32* const chainTable = ms->chainTable; const U32 chainMask = (1 << cParams->chainLog) - 1; const BYTE* const base = ms->window.base; const U32 target = (U32)(ip - base); U32 idx = ms->nextToUpdate; while(idx < target) { /* catch up */ size_t const h = ZSTD_hashPtr(base+idx, hashLog, mls); NEXT_IN_CHAIN(idx, chainMask) = hashTable[h]; hashTable[h] = idx; idx++; } ms->nextToUpdate = target; return hashTable[ZSTD_hashPtr(ip, hashLog, mls)]; } U32 ZSTD_insertAndFindFirstIndex( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip) { return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, cParams->searchLength); } /* inlining is important to hardwire a hot branch (template emulation) */ FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_generic ( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* const ip, const BYTE* const iLimit, size_t* offsetPtr, const U32 mls, const U32 extDict) { U32* const chainTable = ms->chainTable; const U32 chainSize = (1 << cParams->chainLog); const U32 chainMask = chainSize-1; const BYTE* const base = ms->window.base; const BYTE* const dictBase = ms->window.dictBase; const U32 dictLimit = ms->window.dictLimit; const BYTE* const prefixStart = base + dictLimit; const BYTE* const dictEnd = dictBase + dictLimit; const U32 lowLimit = ms->window.lowLimit; const U32 current = (U32)(ip-base); const U32 minChain = current > chainSize ? current - chainSize : 0; U32 nbAttempts = 1U << cParams->searchLog; size_t ml=4-1; /* HC4 match finder */ U32 matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls); for ( ; (matchIndex>lowLimit) & (nbAttempts>0) ; nbAttempts--) { size_t currentMl=0; if ((!extDict) || matchIndex >= dictLimit) { const BYTE* const match = base + matchIndex; if (match[ml] == ip[ml]) /* potentially better */ currentMl = ZSTD_count(ip, match, iLimit); } else { const BYTE* const match = dictBase + matchIndex; assert(match+4 <= dictEnd); if (MEM_read32(match) == MEM_read32(ip)) /* assumption : matchIndex <= dictLimit-4 (by table construction) */ currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4; } /* save best solution */ if (currentMl > ml) { ml = currentMl; *offsetPtr = current - matchIndex + ZSTD_REP_MOVE; if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */ } if (matchIndex <= minChain) break; matchIndex = NEXT_IN_CHAIN(matchIndex, chainMask); } return ml; } FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_selectMLS ( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip, const BYTE* const iLimit, size_t* offsetPtr) { switch(cParams->searchLength) { default : /* includes case 3 */ case 4 : return ZSTD_HcFindBestMatch_generic(ms, cParams, ip, iLimit, offsetPtr, 4, 0); case 5 : return ZSTD_HcFindBestMatch_generic(ms, cParams, ip, iLimit, offsetPtr, 5, 0); case 7 : case 6 : return ZSTD_HcFindBestMatch_generic(ms, cParams, ip, iLimit, offsetPtr, 6, 0); } } FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_extDict_selectMLS ( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip, const BYTE* const iLimit, size_t* const offsetPtr) { switch(cParams->searchLength) { default : /* includes case 3 */ case 4 : return ZSTD_HcFindBestMatch_generic(ms, cParams, ip, iLimit, offsetPtr, 4, 1); case 5 : return ZSTD_HcFindBestMatch_generic(ms, cParams, ip, iLimit, offsetPtr, 5, 1); case 7 : case 6 : return ZSTD_HcFindBestMatch_generic(ms, cParams, ip, iLimit, offsetPtr, 6, 1); } } /* ******************************* * Common parser - lazy strategy *********************************/ FORCE_INLINE_TEMPLATE size_t ZSTD_compressBlock_lazy_generic( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, const void* src, size_t srcSize, const U32 searchMethod, const U32 depth) { const BYTE* const istart = (const BYTE*)src; const BYTE* ip = istart; const BYTE* anchor = istart; const BYTE* const iend = istart + srcSize; const BYTE* const ilimit = iend - 8; const BYTE* const base = ms->window.base + ms->window.dictLimit; typedef size_t (*searchMax_f)( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip, const BYTE* iLimit, size_t* offsetPtr); searchMax_f const searchMax = searchMethod ? ZSTD_BtFindBestMatch_selectMLS : ZSTD_HcFindBestMatch_selectMLS; U32 offset_1 = rep[0], offset_2 = rep[1], savedOffset=0; /* init */ ip += (ip==base); ms->nextToUpdate3 = ms->nextToUpdate; { U32 const maxRep = (U32)(ip-base); if (offset_2 > maxRep) savedOffset = offset_2, offset_2 = 0; if (offset_1 > maxRep) savedOffset = offset_1, offset_1 = 0; } /* Match Loop */ while (ip < ilimit) { size_t matchLength=0; size_t offset=0; const BYTE* start=ip+1; /* check repCode */ if ((offset_1>0) & (MEM_read32(ip+1) == MEM_read32(ip+1 - offset_1))) { /* repcode : we take it */ matchLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4; if (depth==0) goto _storeSequence; } /* first search (depth 0) */ { size_t offsetFound = 99999999; size_t const ml2 = searchMax(ms, cParams, ip, iend, &offsetFound); if (ml2 > matchLength) matchLength = ml2, start = ip, offset=offsetFound; } if (matchLength < 4) { ip += ((ip-anchor) >> kSearchStrength) + 1; /* jump faster over incompressible sections */ continue; } /* let's try to find a better solution */ if (depth>=1) while (ip0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) { size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4; int const gain2 = (int)(mlRep * 3); int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offset+1) + 1); if ((mlRep >= 4) && (gain2 > gain1)) matchLength = mlRep, offset = 0, start = ip; } { size_t offset2=99999999; size_t const ml2 = searchMax(ms, cParams, ip, iend, &offset2); int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)offset2+1)); /* raw approx */ int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 4); if ((ml2 >= 4) && (gain2 > gain1)) { matchLength = ml2, offset = offset2, start = ip; continue; /* search a better one */ } } /* let's find an even better one */ if ((depth==2) && (ip0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) { size_t const ml2 = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4; int const gain2 = (int)(ml2 * 4); int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 1); if ((ml2 >= 4) && (gain2 > gain1)) matchLength = ml2, offset = 0, start = ip; } { size_t offset2=99999999; size_t const ml2 = searchMax(ms, cParams, ip, iend, &offset2); int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)offset2+1)); /* raw approx */ int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 7); if ((ml2 >= 4) && (gain2 > gain1)) { matchLength = ml2, offset = offset2, start = ip; continue; } } } break; /* nothing found : store previous solution */ } /* NOTE: * start[-offset+ZSTD_REP_MOVE-1] is undefined behavior. * (-offset+ZSTD_REP_MOVE-1) is unsigned, and is added to start, which * overflows the pointer, which is undefined behavior. */ /* catch up */ if (offset) { while ( ((start > anchor) & (start - (offset-ZSTD_REP_MOVE) > base)) && (start[-1] == (start-(offset-ZSTD_REP_MOVE))[-1]) ) /* only search for offset within prefix */ { start--; matchLength++; } offset_2 = offset_1; offset_1 = (U32)(offset - ZSTD_REP_MOVE); } /* store sequence */ _storeSequence: { size_t const litLength = start - anchor; ZSTD_storeSeq(seqStore, litLength, anchor, (U32)offset, matchLength-MINMATCH); anchor = ip = start + matchLength; } /* check immediate repcode */ while ( ((ip <= ilimit) & (offset_2>0)) && (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) { /* store sequence */ matchLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4; offset = offset_2; offset_2 = offset_1; offset_1 = (U32)offset; /* swap repcodes */ ZSTD_storeSeq(seqStore, 0, anchor, 0, matchLength-MINMATCH); ip += matchLength; anchor = ip; continue; /* faster when present ... (?) */ } } /* Save reps for next block */ rep[0] = offset_1 ? offset_1 : savedOffset; rep[1] = offset_2 ? offset_2 : savedOffset; /* Return the last literals size */ return iend - anchor; } size_t ZSTD_compressBlock_btlazy2( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, cParams, src, srcSize, 1, 2); } size_t ZSTD_compressBlock_lazy2( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, cParams, src, srcSize, 0, 2); } size_t ZSTD_compressBlock_lazy( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, cParams, src, srcSize, 0, 1); } size_t ZSTD_compressBlock_greedy( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, cParams, src, srcSize, 0, 0); } FORCE_INLINE_TEMPLATE size_t ZSTD_compressBlock_lazy_extDict_generic( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, const void* src, size_t srcSize, const U32 searchMethod, const U32 depth) { const BYTE* const istart = (const BYTE*)src; const BYTE* ip = istart; const BYTE* anchor = istart; const BYTE* const iend = istart + srcSize; const BYTE* const ilimit = iend - 8; const BYTE* const base = ms->window.base; const U32 dictLimit = ms->window.dictLimit; const U32 lowestIndex = ms->window.lowLimit; const BYTE* const prefixStart = base + dictLimit; const BYTE* const dictBase = ms->window.dictBase; const BYTE* const dictEnd = dictBase + dictLimit; const BYTE* const dictStart = dictBase + lowestIndex; typedef size_t (*searchMax_f)( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip, const BYTE* iLimit, size_t* offsetPtr); searchMax_f searchMax = searchMethod ? ZSTD_BtFindBestMatch_selectMLS_extDict : ZSTD_HcFindBestMatch_extDict_selectMLS; U32 offset_1 = rep[0], offset_2 = rep[1]; /* init */ ms->nextToUpdate3 = ms->nextToUpdate; ip += (ip == prefixStart); /* Match Loop */ while (ip < ilimit) { size_t matchLength=0; size_t offset=0; const BYTE* start=ip+1; U32 current = (U32)(ip-base); /* check repCode */ { const U32 repIndex = (U32)(current+1 - offset_1); const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; const BYTE* const repMatch = repBase + repIndex; if (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > lowestIndex)) /* intentional overflow */ if (MEM_read32(ip+1) == MEM_read32(repMatch)) { /* repcode detected we should take it */ const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repEnd, prefixStart) + 4; if (depth==0) goto _storeSequence; } } /* first search (depth 0) */ { size_t offsetFound = 99999999; size_t const ml2 = searchMax(ms, cParams, ip, iend, &offsetFound); if (ml2 > matchLength) matchLength = ml2, start = ip, offset=offsetFound; } if (matchLength < 4) { ip += ((ip-anchor) >> kSearchStrength) + 1; /* jump faster over incompressible sections */ continue; } /* let's try to find a better solution */ if (depth>=1) while (ip= 3) & (repIndex > lowestIndex)) /* intentional overflow */ if (MEM_read32(ip) == MEM_read32(repMatch)) { /* repcode detected */ const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4; int const gain2 = (int)(repLength * 3); int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offset+1) + 1); if ((repLength >= 4) && (gain2 > gain1)) matchLength = repLength, offset = 0, start = ip; } } /* search match, depth 1 */ { size_t offset2=99999999; size_t const ml2 = searchMax(ms, cParams, ip, iend, &offset2); int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)offset2+1)); /* raw approx */ int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 4); if ((ml2 >= 4) && (gain2 > gain1)) { matchLength = ml2, offset = offset2, start = ip; continue; /* search a better one */ } } /* let's find an even better one */ if ((depth==2) && (ip= 3) & (repIndex > lowestIndex)) /* intentional overflow */ if (MEM_read32(ip) == MEM_read32(repMatch)) { /* repcode detected */ const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4; int const gain2 = (int)(repLength * 4); int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 1); if ((repLength >= 4) && (gain2 > gain1)) matchLength = repLength, offset = 0, start = ip; } } /* search match, depth 2 */ { size_t offset2=99999999; size_t const ml2 = searchMax(ms, cParams, ip, iend, &offset2); int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)offset2+1)); /* raw approx */ int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offset+1) + 7); if ((ml2 >= 4) && (gain2 > gain1)) { matchLength = ml2, offset = offset2, start = ip; continue; } } } break; /* nothing found : store previous solution */ } /* catch up */ if (offset) { U32 const matchIndex = (U32)((start-base) - (offset - ZSTD_REP_MOVE)); const BYTE* match = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex; const BYTE* const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart; while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; } /* catch up */ offset_2 = offset_1; offset_1 = (U32)(offset - ZSTD_REP_MOVE); } /* store sequence */ _storeSequence: { size_t const litLength = start - anchor; ZSTD_storeSeq(seqStore, litLength, anchor, (U32)offset, matchLength-MINMATCH); anchor = ip = start + matchLength; } /* check immediate repcode */ while (ip <= ilimit) { const U32 repIndex = (U32)((ip-base) - offset_2); const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; const BYTE* const repMatch = repBase + repIndex; if (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex > lowestIndex)) /* intentional overflow */ if (MEM_read32(ip) == MEM_read32(repMatch)) { /* repcode detected we should take it */ const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4; offset = offset_2; offset_2 = offset_1; offset_1 = (U32)offset; /* swap offset history */ ZSTD_storeSeq(seqStore, 0, anchor, 0, matchLength-MINMATCH); ip += matchLength; anchor = ip; continue; /* faster when present ... (?) */ } break; } } /* Save reps for next block */ rep[0] = offset_1; rep[1] = offset_2; /* Return the last literals size */ return iend - anchor; } size_t ZSTD_compressBlock_greedy_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, cParams, src, srcSize, 0, 0); } size_t ZSTD_compressBlock_lazy_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, cParams, src, srcSize, 0, 1); } size_t ZSTD_compressBlock_lazy2_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, cParams, src, srcSize, 0, 2); } size_t ZSTD_compressBlock_btlazy2_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, cParams, src, srcSize, 1, 2); } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_lazy.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef ZSTD_LAZY_H #define ZSTD_LAZY_H #if defined (__cplusplus) extern "C" { #endif #include "zstd_compress_internal.h" U32 ZSTD_insertAndFindFirstIndex( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip); void ZSTD_preserveUnsortedMark (U32* const table, U32 const size, U32 const reducerValue); /*! used in ZSTD_reduceIndex(). pre-emptively increase value of ZSTD_DUBT_UNSORTED_MARK */ size_t ZSTD_compressBlock_btlazy2( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_lazy2( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_lazy( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_greedy( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_greedy_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_lazy_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_lazy2_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_btlazy2_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); #if defined (__cplusplus) } #endif #endif /* ZSTD_LAZY_H */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_ldm.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). */ #include "zstd_ldm.h" #include "zstd_fast.h" /* ZSTD_fillHashTable() */ #include "zstd_double_fast.h" /* ZSTD_fillDoubleHashTable() */ #define LDM_BUCKET_SIZE_LOG 3 #define LDM_MIN_MATCH_LENGTH 64 #define LDM_HASH_RLOG 7 #define LDM_HASH_CHAR_OFFSET 10 void ZSTD_ldm_adjustParameters(ldmParams_t* params, ZSTD_compressionParameters const* cParams) { U32 const windowLog = cParams->windowLog; ZSTD_STATIC_ASSERT(LDM_BUCKET_SIZE_LOG <= ZSTD_LDM_BUCKETSIZELOG_MAX); DEBUGLOG(4, "ZSTD_ldm_adjustParameters"); if (!params->bucketSizeLog) params->bucketSizeLog = LDM_BUCKET_SIZE_LOG; if (!params->minMatchLength) params->minMatchLength = LDM_MIN_MATCH_LENGTH; if (cParams->strategy >= ZSTD_btopt) { /* Get out of the way of the optimal parser */ U32 const minMatch = MAX(cParams->targetLength, params->minMatchLength); assert(minMatch >= ZSTD_LDM_MINMATCH_MIN); assert(minMatch <= ZSTD_LDM_MINMATCH_MAX); params->minMatchLength = minMatch; } if (params->hashLog == 0) { params->hashLog = MAX(ZSTD_HASHLOG_MIN, windowLog - LDM_HASH_RLOG); assert(params->hashLog <= ZSTD_HASHLOG_MAX); } if (params->hashEveryLog == 0) { params->hashEveryLog = windowLog < params->hashLog ? 0 : windowLog - params->hashLog; } params->bucketSizeLog = MIN(params->bucketSizeLog, params->hashLog); } size_t ZSTD_ldm_getTableSize(ldmParams_t params) { size_t const ldmHSize = ((size_t)1) << params.hashLog; size_t const ldmBucketSizeLog = MIN(params.bucketSizeLog, params.hashLog); size_t const ldmBucketSize = ((size_t)1) << (params.hashLog - ldmBucketSizeLog); size_t const totalSize = ldmBucketSize + ldmHSize * sizeof(ldmEntry_t); return params.enableLdm ? totalSize : 0; } size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize) { return params.enableLdm ? (maxChunkSize / params.minMatchLength) : 0; } /** ZSTD_ldm_getSmallHash() : * numBits should be <= 32 * If numBits==0, returns 0. * @return : the most significant numBits of value. */ static U32 ZSTD_ldm_getSmallHash(U64 value, U32 numBits) { assert(numBits <= 32); return numBits == 0 ? 0 : (U32)(value >> (64 - numBits)); } /** ZSTD_ldm_getChecksum() : * numBitsToDiscard should be <= 32 * @return : the next most significant 32 bits after numBitsToDiscard */ static U32 ZSTD_ldm_getChecksum(U64 hash, U32 numBitsToDiscard) { assert(numBitsToDiscard <= 32); return (hash >> (64 - 32 - numBitsToDiscard)) & 0xFFFFFFFF; } /** ZSTD_ldm_getTag() ; * Given the hash, returns the most significant numTagBits bits * after (32 + hbits) bits. * * If there are not enough bits remaining, return the last * numTagBits bits. */ static U32 ZSTD_ldm_getTag(U64 hash, U32 hbits, U32 numTagBits) { assert(numTagBits < 32 && hbits <= 32); if (32 - hbits < numTagBits) { return hash & (((U32)1 << numTagBits) - 1); } else { return (hash >> (32 - hbits - numTagBits)) & (((U32)1 << numTagBits) - 1); } } /** ZSTD_ldm_getBucket() : * Returns a pointer to the start of the bucket associated with hash. */ static ldmEntry_t* ZSTD_ldm_getBucket( ldmState_t* ldmState, size_t hash, ldmParams_t const ldmParams) { return ldmState->hashTable + (hash << ldmParams.bucketSizeLog); } /** ZSTD_ldm_insertEntry() : * Insert the entry with corresponding hash into the hash table */ static void ZSTD_ldm_insertEntry(ldmState_t* ldmState, size_t const hash, const ldmEntry_t entry, ldmParams_t const ldmParams) { BYTE* const bucketOffsets = ldmState->bucketOffsets; *(ZSTD_ldm_getBucket(ldmState, hash, ldmParams) + bucketOffsets[hash]) = entry; bucketOffsets[hash]++; bucketOffsets[hash] &= ((U32)1 << ldmParams.bucketSizeLog) - 1; } /** ZSTD_ldm_makeEntryAndInsertByTag() : * * Gets the small hash, checksum, and tag from the rollingHash. * * If the tag matches (1 << ldmParams.hashEveryLog)-1, then * creates an ldmEntry from the offset, and inserts it into the hash table. * * hBits is the length of the small hash, which is the most significant hBits * of rollingHash. The checksum is the next 32 most significant bits, followed * by ldmParams.hashEveryLog bits that make up the tag. */ static void ZSTD_ldm_makeEntryAndInsertByTag(ldmState_t* ldmState, U64 const rollingHash, U32 const hBits, U32 const offset, ldmParams_t const ldmParams) { U32 const tag = ZSTD_ldm_getTag(rollingHash, hBits, ldmParams.hashEveryLog); U32 const tagMask = ((U32)1 << ldmParams.hashEveryLog) - 1; if (tag == tagMask) { U32 const hash = ZSTD_ldm_getSmallHash(rollingHash, hBits); U32 const checksum = ZSTD_ldm_getChecksum(rollingHash, hBits); ldmEntry_t entry; entry.offset = offset; entry.checksum = checksum; ZSTD_ldm_insertEntry(ldmState, hash, entry, ldmParams); } } /** ZSTD_ldm_getRollingHash() : * Get a 64-bit hash using the first len bytes from buf. * * Giving bytes s = s_1, s_2, ... s_k, the hash is defined to be * H(s) = s_1*(a^(k-1)) + s_2*(a^(k-2)) + ... + s_k*(a^0) * * where the constant a is defined to be prime8bytes. * * The implementation adds an offset to each byte, so * H(s) = (s_1 + HASH_CHAR_OFFSET)*(a^(k-1)) + ... */ static U64 ZSTD_ldm_getRollingHash(const BYTE* buf, U32 len) { U64 ret = 0; U32 i; for (i = 0; i < len; i++) { ret *= prime8bytes; ret += buf[i] + LDM_HASH_CHAR_OFFSET; } return ret; } /** ZSTD_ldm_ipow() : * Return base^exp. */ static U64 ZSTD_ldm_ipow(U64 base, U64 exp) { U64 ret = 1; while (exp) { if (exp & 1) { ret *= base; } exp >>= 1; base *= base; } return ret; } U64 ZSTD_ldm_getHashPower(U32 minMatchLength) { DEBUGLOG(4, "ZSTD_ldm_getHashPower: mml=%u", minMatchLength); assert(minMatchLength >= ZSTD_LDM_MINMATCH_MIN); return ZSTD_ldm_ipow(prime8bytes, minMatchLength - 1); } /** ZSTD_ldm_updateHash() : * Updates hash by removing toRemove and adding toAdd. */ static U64 ZSTD_ldm_updateHash(U64 hash, BYTE toRemove, BYTE toAdd, U64 hashPower) { hash -= ((toRemove + LDM_HASH_CHAR_OFFSET) * hashPower); hash *= prime8bytes; hash += toAdd + LDM_HASH_CHAR_OFFSET; return hash; } /** ZSTD_ldm_countBackwardsMatch() : * Returns the number of bytes that match backwards before pIn and pMatch. * * We count only bytes where pMatch >= pBase and pIn >= pAnchor. */ static size_t ZSTD_ldm_countBackwardsMatch( const BYTE* pIn, const BYTE* pAnchor, const BYTE* pMatch, const BYTE* pBase) { size_t matchLength = 0; while (pIn > pAnchor && pMatch > pBase && pIn[-1] == pMatch[-1]) { pIn--; pMatch--; matchLength++; } return matchLength; } /** ZSTD_ldm_fillFastTables() : * * Fills the relevant tables for the ZSTD_fast and ZSTD_dfast strategies. * This is similar to ZSTD_loadDictionaryContent. * * The tables for the other strategies are filled within their * block compressors. */ static size_t ZSTD_ldm_fillFastTables(ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, void const* end) { const BYTE* const iend = (const BYTE*)end; switch(cParams->strategy) { case ZSTD_fast: ZSTD_fillHashTable(ms, cParams, iend); ms->nextToUpdate = (U32)(iend - ms->window.base); break; case ZSTD_dfast: ZSTD_fillDoubleHashTable(ms, cParams, iend); ms->nextToUpdate = (U32)(iend - ms->window.base); break; case ZSTD_greedy: case ZSTD_lazy: case ZSTD_lazy2: case ZSTD_btlazy2: case ZSTD_btopt: case ZSTD_btultra: break; default: assert(0); /* not possible : not a valid strategy id */ } return 0; } /** ZSTD_ldm_fillLdmHashTable() : * * Fills hashTable from (lastHashed + 1) to iend (non-inclusive). * lastHash is the rolling hash that corresponds to lastHashed. * * Returns the rolling hash corresponding to position iend-1. */ static U64 ZSTD_ldm_fillLdmHashTable(ldmState_t* state, U64 lastHash, const BYTE* lastHashed, const BYTE* iend, const BYTE* base, U32 hBits, ldmParams_t const ldmParams) { U64 rollingHash = lastHash; const BYTE* cur = lastHashed + 1; while (cur < iend) { rollingHash = ZSTD_ldm_updateHash(rollingHash, cur[-1], cur[ldmParams.minMatchLength-1], state->hashPower); ZSTD_ldm_makeEntryAndInsertByTag(state, rollingHash, hBits, (U32)(cur - base), ldmParams); ++cur; } return rollingHash; } /** ZSTD_ldm_limitTableUpdate() : * * Sets cctx->nextToUpdate to a position corresponding closer to anchor * if it is far way * (after a long match, only update tables a limited amount). */ static void ZSTD_ldm_limitTableUpdate(ZSTD_matchState_t* ms, const BYTE* anchor) { U32 const current = (U32)(anchor - ms->window.base); if (current > ms->nextToUpdate + 1024) { ms->nextToUpdate = current - MIN(512, current - ms->nextToUpdate - 1024); } } static size_t ZSTD_ldm_generateSequences_internal( ldmState_t* ldmState, rawSeqStore_t* rawSeqStore, ldmParams_t const* params, void const* src, size_t srcSize) { /* LDM parameters */ int const extDict = ZSTD_window_hasExtDict(ldmState->window); U32 const minMatchLength = params->minMatchLength; U64 const hashPower = ldmState->hashPower; U32 const hBits = params->hashLog - params->bucketSizeLog; U32 const ldmBucketSize = 1U << params->bucketSizeLog; U32 const hashEveryLog = params->hashEveryLog; U32 const ldmTagMask = (1U << params->hashEveryLog) - 1; /* Prefix and extDict parameters */ U32 const dictLimit = ldmState->window.dictLimit; U32 const lowestIndex = extDict ? ldmState->window.lowLimit : dictLimit; BYTE const* const base = ldmState->window.base; BYTE const* const dictBase = extDict ? ldmState->window.dictBase : NULL; BYTE const* const dictStart = extDict ? dictBase + lowestIndex : NULL; BYTE const* const dictEnd = extDict ? dictBase + dictLimit : NULL; BYTE const* const lowPrefixPtr = base + dictLimit; /* Input bounds */ BYTE const* const istart = (BYTE const*)src; BYTE const* const iend = istart + srcSize; BYTE const* const ilimit = iend - MAX(minMatchLength, HASH_READ_SIZE); /* Input positions */ BYTE const* anchor = istart; BYTE const* ip = istart; /* Rolling hash */ BYTE const* lastHashed = NULL; U64 rollingHash = 0; while (ip <= ilimit) { size_t mLength; U32 const current = (U32)(ip - base); size_t forwardMatchLength = 0, backwardMatchLength = 0; ldmEntry_t* bestEntry = NULL; if (ip != istart) { rollingHash = ZSTD_ldm_updateHash(rollingHash, lastHashed[0], lastHashed[minMatchLength], hashPower); } else { rollingHash = ZSTD_ldm_getRollingHash(ip, minMatchLength); } lastHashed = ip; /* Do not insert and do not look for a match */ if (ZSTD_ldm_getTag(rollingHash, hBits, hashEveryLog) != ldmTagMask) { ip++; continue; } /* Get the best entry and compute the match lengths */ { ldmEntry_t* const bucket = ZSTD_ldm_getBucket(ldmState, ZSTD_ldm_getSmallHash(rollingHash, hBits), *params); ldmEntry_t* cur; size_t bestMatchLength = 0; U32 const checksum = ZSTD_ldm_getChecksum(rollingHash, hBits); for (cur = bucket; cur < bucket + ldmBucketSize; ++cur) { size_t curForwardMatchLength, curBackwardMatchLength, curTotalMatchLength; if (cur->checksum != checksum || cur->offset <= lowestIndex) { continue; } if (extDict) { BYTE const* const curMatchBase = cur->offset < dictLimit ? dictBase : base; BYTE const* const pMatch = curMatchBase + cur->offset; BYTE const* const matchEnd = cur->offset < dictLimit ? dictEnd : iend; BYTE const* const lowMatchPtr = cur->offset < dictLimit ? dictStart : lowPrefixPtr; curForwardMatchLength = ZSTD_count_2segments( ip, pMatch, iend, matchEnd, lowPrefixPtr); if (curForwardMatchLength < minMatchLength) { continue; } curBackwardMatchLength = ZSTD_ldm_countBackwardsMatch(ip, anchor, pMatch, lowMatchPtr); curTotalMatchLength = curForwardMatchLength + curBackwardMatchLength; } else { /* !extDict */ BYTE const* const pMatch = base + cur->offset; curForwardMatchLength = ZSTD_count(ip, pMatch, iend); if (curForwardMatchLength < minMatchLength) { continue; } curBackwardMatchLength = ZSTD_ldm_countBackwardsMatch(ip, anchor, pMatch, lowPrefixPtr); curTotalMatchLength = curForwardMatchLength + curBackwardMatchLength; } if (curTotalMatchLength > bestMatchLength) { bestMatchLength = curTotalMatchLength; forwardMatchLength = curForwardMatchLength; backwardMatchLength = curBackwardMatchLength; bestEntry = cur; } } } /* No match found -- continue searching */ if (bestEntry == NULL) { ZSTD_ldm_makeEntryAndInsertByTag(ldmState, rollingHash, hBits, current, *params); ip++; continue; } /* Match found */ mLength = forwardMatchLength + backwardMatchLength; ip -= backwardMatchLength; { /* Store the sequence: * ip = current - backwardMatchLength * The match is at (bestEntry->offset - backwardMatchLength) */ U32 const matchIndex = bestEntry->offset; U32 const offset = current - matchIndex; rawSeq* const seq = rawSeqStore->seq + rawSeqStore->size; /* Out of sequence storage */ if (rawSeqStore->size == rawSeqStore->capacity) return ERROR(dstSize_tooSmall); seq->litLength = (U32)(ip - anchor); seq->matchLength = (U32)mLength; seq->offset = offset; rawSeqStore->size++; } /* Insert the current entry into the hash table */ ZSTD_ldm_makeEntryAndInsertByTag(ldmState, rollingHash, hBits, (U32)(lastHashed - base), *params); assert(ip + backwardMatchLength == lastHashed); /* Fill the hash table from lastHashed+1 to ip+mLength*/ /* Heuristic: don't need to fill the entire table at end of block */ if (ip + mLength <= ilimit) { rollingHash = ZSTD_ldm_fillLdmHashTable( ldmState, rollingHash, lastHashed, ip + mLength, base, hBits, *params); lastHashed = ip + mLength - 1; } ip += mLength; anchor = ip; } return iend - anchor; } /*! ZSTD_ldm_reduceTable() : * reduce table indexes by `reducerValue` */ static void ZSTD_ldm_reduceTable(ldmEntry_t* const table, U32 const size, U32 const reducerValue) { U32 u; for (u = 0; u < size; u++) { if (table[u].offset < reducerValue) table[u].offset = 0; else table[u].offset -= reducerValue; } } size_t ZSTD_ldm_generateSequences( ldmState_t* ldmState, rawSeqStore_t* sequences, ldmParams_t const* params, void const* src, size_t srcSize) { U32 const maxDist = 1U << params->windowLog; BYTE const* const istart = (BYTE const*)src; BYTE const* const iend = istart + srcSize; size_t const kMaxChunkSize = 1 << 20; size_t const nbChunks = (srcSize / kMaxChunkSize) + ((srcSize % kMaxChunkSize) != 0); size_t chunk; size_t leftoverSize = 0; assert(ZSTD_CHUNKSIZE_MAX >= kMaxChunkSize); /* Check that ZSTD_window_update() has been called for this chunk prior * to passing it to this function. */ assert(ldmState->window.nextSrc >= (BYTE const*)src + srcSize); /* The input could be very large (in zstdmt), so it must be broken up into * chunks to enforce the maximmum distance and handle overflow correction. */ assert(sequences->pos <= sequences->size); assert(sequences->size <= sequences->capacity); for (chunk = 0; chunk < nbChunks && sequences->size < sequences->capacity; ++chunk) { BYTE const* const chunkStart = istart + chunk * kMaxChunkSize; size_t const remaining = (size_t)(iend - chunkStart); BYTE const *const chunkEnd = (remaining < kMaxChunkSize) ? iend : chunkStart + kMaxChunkSize; size_t const chunkSize = chunkEnd - chunkStart; size_t newLeftoverSize; size_t const prevSize = sequences->size; assert(chunkStart < iend); /* 1. Perform overflow correction if necessary. */ if (ZSTD_window_needOverflowCorrection(ldmState->window, chunkEnd)) { U32 const ldmHSize = 1U << params->hashLog; U32 const correction = ZSTD_window_correctOverflow( &ldmState->window, /* cycleLog */ 0, maxDist, src); ZSTD_ldm_reduceTable(ldmState->hashTable, ldmHSize, correction); } /* 2. We enforce the maximum offset allowed. * * kMaxChunkSize should be small enough that we don't lose too much of * the window through early invalidation. * TODO: * Test the chunk size. * * Try invalidation after the sequence generation and test the * the offset against maxDist directly. */ ZSTD_window_enforceMaxDist(&ldmState->window, chunkEnd, maxDist, NULL); /* 3. Generate the sequences for the chunk, and get newLeftoverSize. */ newLeftoverSize = ZSTD_ldm_generateSequences_internal( ldmState, sequences, params, chunkStart, chunkSize); if (ZSTD_isError(newLeftoverSize)) return newLeftoverSize; /* 4. We add the leftover literals from previous iterations to the first * newly generated sequence, or add the `newLeftoverSize` if none are * generated. */ /* Prepend the leftover literals from the last call */ if (prevSize < sequences->size) { sequences->seq[prevSize].litLength += (U32)leftoverSize; leftoverSize = newLeftoverSize; } else { assert(newLeftoverSize == chunkSize); leftoverSize += chunkSize; } } return 0; } void ZSTD_ldm_skipSequences(rawSeqStore_t* rawSeqStore, size_t srcSize, U32 const minMatch) { while (srcSize > 0 && rawSeqStore->pos < rawSeqStore->size) { rawSeq* seq = rawSeqStore->seq + rawSeqStore->pos; if (srcSize <= seq->litLength) { /* Skip past srcSize literals */ seq->litLength -= (U32)srcSize; return; } srcSize -= seq->litLength; seq->litLength = 0; if (srcSize < seq->matchLength) { /* Skip past the first srcSize of the match */ seq->matchLength -= (U32)srcSize; if (seq->matchLength < minMatch) { /* The match is too short, omit it */ if (rawSeqStore->pos + 1 < rawSeqStore->size) { seq[1].litLength += seq[0].matchLength; } rawSeqStore->pos++; } return; } srcSize -= seq->matchLength; seq->matchLength = 0; rawSeqStore->pos++; } } /** * If the sequence length is longer than remaining then the sequence is split * between this block and the next. * * Returns the current sequence to handle, or if the rest of the block should * be literals, it returns a sequence with offset == 0. */ static rawSeq maybeSplitSequence(rawSeqStore_t* rawSeqStore, U32 const remaining, U32 const minMatch) { rawSeq sequence = rawSeqStore->seq[rawSeqStore->pos]; assert(sequence.offset > 0); /* Likely: No partial sequence */ if (remaining >= sequence.litLength + sequence.matchLength) { rawSeqStore->pos++; return sequence; } /* Cut the sequence short (offset == 0 ==> rest is literals). */ if (remaining <= sequence.litLength) { sequence.offset = 0; } else if (remaining < sequence.litLength + sequence.matchLength) { sequence.matchLength = remaining - sequence.litLength; if (sequence.matchLength < minMatch) { sequence.offset = 0; } } /* Skip past `remaining` bytes for the future sequences. */ ZSTD_ldm_skipSequences(rawSeqStore, remaining, minMatch); return sequence; } size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore, ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize, int const extDict) { unsigned const minMatch = cParams->searchLength; ZSTD_blockCompressor const blockCompressor = ZSTD_selectBlockCompressor(cParams->strategy, extDict); BYTE const* const base = ms->window.base; /* Input bounds */ BYTE const* const istart = (BYTE const*)src; BYTE const* const iend = istart + srcSize; /* Input positions */ BYTE const* ip = istart; assert(rawSeqStore->pos <= rawSeqStore->size); assert(rawSeqStore->size <= rawSeqStore->capacity); /* Loop through each sequence and apply the block compressor to the lits */ while (rawSeqStore->pos < rawSeqStore->size && ip < iend) { /* maybeSplitSequence updates rawSeqStore->pos */ rawSeq const sequence = maybeSplitSequence(rawSeqStore, (U32)(iend - ip), minMatch); int i; /* End signal */ if (sequence.offset == 0) break; assert(sequence.offset <= (1U << cParams->windowLog)); assert(ip + sequence.litLength + sequence.matchLength <= iend); /* Fill tables for block compressor */ ZSTD_ldm_limitTableUpdate(ms, ip); ZSTD_ldm_fillFastTables(ms, cParams, ip); /* Run the block compressor */ { size_t const newLitLength = blockCompressor(ms, seqStore, rep, cParams, ip, sequence.litLength); ip += sequence.litLength; ms->nextToUpdate = (U32)(ip - base); /* Update the repcodes */ for (i = ZSTD_REP_NUM - 1; i > 0; i--) rep[i] = rep[i-1]; rep[0] = sequence.offset; /* Store the sequence */ ZSTD_storeSeq(seqStore, newLitLength, ip - newLitLength, sequence.offset + ZSTD_REP_MOVE, sequence.matchLength - MINMATCH); ip += sequence.matchLength; } } /* Fill the tables for the block compressor */ ZSTD_ldm_limitTableUpdate(ms, ip); ZSTD_ldm_fillFastTables(ms, cParams, ip); /* Compress the last literals */ { size_t const lastLiterals = blockCompressor(ms, seqStore, rep, cParams, ip, iend - ip); ms->nextToUpdate = (U32)(iend - base); return lastLiterals; } } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_ldm.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). */ #ifndef ZSTD_LDM_H #define ZSTD_LDM_H #if defined (__cplusplus) extern "C" { #endif #include "zstd_compress_internal.h" /* ldmParams_t, U32 */ #include "zstd.h" /* ZSTD_CCtx, size_t */ /*-************************************* * Long distance matching ***************************************/ #define ZSTD_LDM_DEFAULT_WINDOW_LOG ZSTD_WINDOWLOG_DEFAULTMAX /** * ZSTD_ldm_generateSequences(): * * Generates the sequences using the long distance match finder. * Generates long range matching sequences in `sequences`, which parse a prefix * of the source. `sequences` must be large enough to store every sequence, * which can be checked with `ZSTD_ldm_getMaxNbSeq()`. * @returns 0 or an error code. * * NOTE: The user must have called ZSTD_window_update() for all of the input * they have, even if they pass it to ZSTD_ldm_generateSequences() in chunks. * NOTE: This function returns an error if it runs out of space to store * sequences. */ size_t ZSTD_ldm_generateSequences( ldmState_t* ldms, rawSeqStore_t* sequences, ldmParams_t const* params, void const* src, size_t srcSize); /** * ZSTD_ldm_blockCompress(): * * Compresses a block using the predefined sequences, along with a secondary * block compressor. The literals section of every sequence is passed to the * secondary block compressor, and those sequences are interspersed with the * predefined sequences. Returns the length of the last literals. * Updates `rawSeqStore.pos` to indicate how many sequences have been consumed. * `rawSeqStore.seq` may also be updated to split the last sequence between two * blocks. * @return The length of the last literals. * * NOTE: The source must be at most the maximum block size, but the predefined * sequences can be any size, and may be longer than the block. In the case that * they are longer than the block, the last sequences may need to be split into * two. We handle that case correctly, and update `rawSeqStore` appropriately. * NOTE: This function does not return any errors. */ size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore, ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize, int const extDict); /** * ZSTD_ldm_skipSequences(): * * Skip past `srcSize` bytes worth of sequences in `rawSeqStore`. * Avoids emitting matches less than `minMatch` bytes. * Must be called for data with is not passed to ZSTD_ldm_blockCompress(). */ void ZSTD_ldm_skipSequences(rawSeqStore_t* rawSeqStore, size_t srcSize, U32 const minMatch); /** ZSTD_ldm_getTableSize() : * Estimate the space needed for long distance matching tables or 0 if LDM is * disabled. */ size_t ZSTD_ldm_getTableSize(ldmParams_t params); /** ZSTD_ldm_getSeqSpace() : * Return an upper bound on the number of sequences that can be produced by * the long distance matcher, or 0 if LDM is disabled. */ size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize); /** ZSTD_ldm_getTableSize() : * Return prime8bytes^(minMatchLength-1) */ U64 ZSTD_ldm_getHashPower(U32 minMatchLength); /** ZSTD_ldm_adjustParameters() : * If the params->hashEveryLog is not set, set it to its default value based on * windowLog and params->hashLog. * * Ensures that params->bucketSizeLog is <= params->hashLog (setting it to * params->hashLog if it is not). * * Ensures that the minMatchLength >= targetLength during optimal parsing. */ void ZSTD_ldm_adjustParameters(ldmParams_t* params, ZSTD_compressionParameters const* cParams); #if defined (__cplusplus) } #endif #endif /* ZSTD_FAST_H */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_legacy.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef ZSTD_LEGACY_H #define ZSTD_LEGACY_H #if defined (__cplusplus) extern "C" { #endif /* ************************************* * Includes ***************************************/ #include "mem.h" /* MEM_STATIC */ #include "error_private.h" /* ERROR */ #include "zstd.h" /* ZSTD_inBuffer, ZSTD_outBuffer */ #if !defined (ZSTD_LEGACY_SUPPORT) || (ZSTD_LEGACY_SUPPORT == 0) # undef ZSTD_LEGACY_SUPPORT # define ZSTD_LEGACY_SUPPORT 8 #endif #if (ZSTD_LEGACY_SUPPORT <= 1) # include "zstd_v01.h" #endif #if (ZSTD_LEGACY_SUPPORT <= 2) # include "zstd_v02.h" #endif #if (ZSTD_LEGACY_SUPPORT <= 3) # include "zstd_v03.h" #endif #if (ZSTD_LEGACY_SUPPORT <= 4) # include "zstd_v04.h" #endif #if (ZSTD_LEGACY_SUPPORT <= 5) # include "zstd_v05.h" #endif #if (ZSTD_LEGACY_SUPPORT <= 6) # include "zstd_v06.h" #endif #if (ZSTD_LEGACY_SUPPORT <= 7) # include "zstd_v07.h" #endif /** ZSTD_isLegacy() : @return : > 0 if supported by legacy decoder. 0 otherwise. return value is the version. */ MEM_STATIC unsigned ZSTD_isLegacy(const void* src, size_t srcSize) { U32 magicNumberLE; if (srcSize<4) return 0; magicNumberLE = MEM_readLE32(src); switch(magicNumberLE) { #if (ZSTD_LEGACY_SUPPORT <= 1) case ZSTDv01_magicNumberLE:return 1; #endif #if (ZSTD_LEGACY_SUPPORT <= 2) case ZSTDv02_magicNumber : return 2; #endif #if (ZSTD_LEGACY_SUPPORT <= 3) case ZSTDv03_magicNumber : return 3; #endif #if (ZSTD_LEGACY_SUPPORT <= 4) case ZSTDv04_magicNumber : return 4; #endif #if (ZSTD_LEGACY_SUPPORT <= 5) case ZSTDv05_MAGICNUMBER : return 5; #endif #if (ZSTD_LEGACY_SUPPORT <= 6) case ZSTDv06_MAGICNUMBER : return 6; #endif #if (ZSTD_LEGACY_SUPPORT <= 7) case ZSTDv07_MAGICNUMBER : return 7; #endif default : return 0; } } MEM_STATIC unsigned long long ZSTD_getDecompressedSize_legacy(const void* src, size_t srcSize) { U32 const version = ZSTD_isLegacy(src, srcSize); if (version < 5) return 0; /* no decompressed size in frame header, or not a legacy format */ #if (ZSTD_LEGACY_SUPPORT <= 5) if (version==5) { ZSTDv05_parameters fParams; size_t const frResult = ZSTDv05_getFrameParams(&fParams, src, srcSize); if (frResult != 0) return 0; return fParams.srcSize; } #endif #if (ZSTD_LEGACY_SUPPORT <= 6) if (version==6) { ZSTDv06_frameParams fParams; size_t const frResult = ZSTDv06_getFrameParams(&fParams, src, srcSize); if (frResult != 0) return 0; return fParams.frameContentSize; } #endif #if (ZSTD_LEGACY_SUPPORT <= 7) if (version==7) { ZSTDv07_frameParams fParams; size_t const frResult = ZSTDv07_getFrameParams(&fParams, src, srcSize); if (frResult != 0) return 0; return fParams.frameContentSize; } #endif return 0; /* should not be possible */ } MEM_STATIC size_t ZSTD_decompressLegacy( void* dst, size_t dstCapacity, const void* src, size_t compressedSize, const void* dict,size_t dictSize) { U32 const version = ZSTD_isLegacy(src, compressedSize); (void)dst; (void)dstCapacity; (void)dict; (void)dictSize; /* unused when ZSTD_LEGACY_SUPPORT >= 8 */ switch(version) { #if (ZSTD_LEGACY_SUPPORT <= 1) case 1 : return ZSTDv01_decompress(dst, dstCapacity, src, compressedSize); #endif #if (ZSTD_LEGACY_SUPPORT <= 2) case 2 : return ZSTDv02_decompress(dst, dstCapacity, src, compressedSize); #endif #if (ZSTD_LEGACY_SUPPORT <= 3) case 3 : return ZSTDv03_decompress(dst, dstCapacity, src, compressedSize); #endif #if (ZSTD_LEGACY_SUPPORT <= 4) case 4 : return ZSTDv04_decompress(dst, dstCapacity, src, compressedSize); #endif #if (ZSTD_LEGACY_SUPPORT <= 5) case 5 : { size_t result; ZSTDv05_DCtx* const zd = ZSTDv05_createDCtx(); if (zd==NULL) return ERROR(memory_allocation); result = ZSTDv05_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize); ZSTDv05_freeDCtx(zd); return result; } #endif #if (ZSTD_LEGACY_SUPPORT <= 6) case 6 : { size_t result; ZSTDv06_DCtx* const zd = ZSTDv06_createDCtx(); if (zd==NULL) return ERROR(memory_allocation); result = ZSTDv06_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize); ZSTDv06_freeDCtx(zd); return result; } #endif #if (ZSTD_LEGACY_SUPPORT <= 7) case 7 : { size_t result; ZSTDv07_DCtx* const zd = ZSTDv07_createDCtx(); if (zd==NULL) return ERROR(memory_allocation); result = ZSTDv07_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize); ZSTDv07_freeDCtx(zd); return result; } #endif default : return ERROR(prefix_unknown); } } MEM_STATIC size_t ZSTD_findFrameCompressedSizeLegacy(const void *src, size_t compressedSize) { U32 const version = ZSTD_isLegacy(src, compressedSize); switch(version) { #if (ZSTD_LEGACY_SUPPORT <= 1) case 1 : return ZSTDv01_findFrameCompressedSize(src, compressedSize); #endif #if (ZSTD_LEGACY_SUPPORT <= 2) case 2 : return ZSTDv02_findFrameCompressedSize(src, compressedSize); #endif #if (ZSTD_LEGACY_SUPPORT <= 3) case 3 : return ZSTDv03_findFrameCompressedSize(src, compressedSize); #endif #if (ZSTD_LEGACY_SUPPORT <= 4) case 4 : return ZSTDv04_findFrameCompressedSize(src, compressedSize); #endif #if (ZSTD_LEGACY_SUPPORT <= 5) case 5 : return ZSTDv05_findFrameCompressedSize(src, compressedSize); #endif #if (ZSTD_LEGACY_SUPPORT <= 6) case 6 : return ZSTDv06_findFrameCompressedSize(src, compressedSize); #endif #if (ZSTD_LEGACY_SUPPORT <= 7) case 7 : return ZSTDv07_findFrameCompressedSize(src, compressedSize); #endif default : return ERROR(prefix_unknown); } } MEM_STATIC size_t ZSTD_freeLegacyStreamContext(void* legacyContext, U32 version) { switch(version) { default : case 1 : case 2 : case 3 : (void)legacyContext; return ERROR(version_unsupported); #if (ZSTD_LEGACY_SUPPORT <= 4) case 4 : return ZBUFFv04_freeDCtx((ZBUFFv04_DCtx*)legacyContext); #endif #if (ZSTD_LEGACY_SUPPORT <= 5) case 5 : return ZBUFFv05_freeDCtx((ZBUFFv05_DCtx*)legacyContext); #endif #if (ZSTD_LEGACY_SUPPORT <= 6) case 6 : return ZBUFFv06_freeDCtx((ZBUFFv06_DCtx*)legacyContext); #endif #if (ZSTD_LEGACY_SUPPORT <= 7) case 7 : return ZBUFFv07_freeDCtx((ZBUFFv07_DCtx*)legacyContext); #endif } } MEM_STATIC size_t ZSTD_initLegacyStream(void** legacyContext, U32 prevVersion, U32 newVersion, const void* dict, size_t dictSize) { DEBUGLOG(5, "ZSTD_initLegacyStream for v0.%u", newVersion); if (prevVersion != newVersion) ZSTD_freeLegacyStreamContext(*legacyContext, prevVersion); switch(newVersion) { default : case 1 : case 2 : case 3 : (void)dict; (void)dictSize; return 0; #if (ZSTD_LEGACY_SUPPORT <= 4) case 4 : { ZBUFFv04_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv04_createDCtx() : (ZBUFFv04_DCtx*)*legacyContext; if (dctx==NULL) return ERROR(memory_allocation); ZBUFFv04_decompressInit(dctx); ZBUFFv04_decompressWithDictionary(dctx, dict, dictSize); *legacyContext = dctx; return 0; } #endif #if (ZSTD_LEGACY_SUPPORT <= 5) case 5 : { ZBUFFv05_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv05_createDCtx() : (ZBUFFv05_DCtx*)*legacyContext; if (dctx==NULL) return ERROR(memory_allocation); ZBUFFv05_decompressInitDictionary(dctx, dict, dictSize); *legacyContext = dctx; return 0; } #endif #if (ZSTD_LEGACY_SUPPORT <= 6) case 6 : { ZBUFFv06_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv06_createDCtx() : (ZBUFFv06_DCtx*)*legacyContext; if (dctx==NULL) return ERROR(memory_allocation); ZBUFFv06_decompressInitDictionary(dctx, dict, dictSize); *legacyContext = dctx; return 0; } #endif #if (ZSTD_LEGACY_SUPPORT <= 7) case 7 : { ZBUFFv07_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv07_createDCtx() : (ZBUFFv07_DCtx*)*legacyContext; if (dctx==NULL) return ERROR(memory_allocation); ZBUFFv07_decompressInitDictionary(dctx, dict, dictSize); *legacyContext = dctx; return 0; } #endif } } MEM_STATIC size_t ZSTD_decompressLegacyStream(void* legacyContext, U32 version, ZSTD_outBuffer* output, ZSTD_inBuffer* input) { DEBUGLOG(5, "ZSTD_decompressLegacyStream for v0.%u", version); switch(version) { default : case 1 : case 2 : case 3 : (void)legacyContext; (void)output; (void)input; return ERROR(version_unsupported); #if (ZSTD_LEGACY_SUPPORT <= 4) case 4 : { ZBUFFv04_DCtx* dctx = (ZBUFFv04_DCtx*) legacyContext; const void* src = (const char*)input->src + input->pos; size_t readSize = input->size - input->pos; void* dst = (char*)output->dst + output->pos; size_t decodedSize = output->size - output->pos; size_t const hintSize = ZBUFFv04_decompressContinue(dctx, dst, &decodedSize, src, &readSize); output->pos += decodedSize; input->pos += readSize; return hintSize; } #endif #if (ZSTD_LEGACY_SUPPORT <= 5) case 5 : { ZBUFFv05_DCtx* dctx = (ZBUFFv05_DCtx*) legacyContext; const void* src = (const char*)input->src + input->pos; size_t readSize = input->size - input->pos; void* dst = (char*)output->dst + output->pos; size_t decodedSize = output->size - output->pos; size_t const hintSize = ZBUFFv05_decompressContinue(dctx, dst, &decodedSize, src, &readSize); output->pos += decodedSize; input->pos += readSize; return hintSize; } #endif #if (ZSTD_LEGACY_SUPPORT <= 6) case 6 : { ZBUFFv06_DCtx* dctx = (ZBUFFv06_DCtx*) legacyContext; const void* src = (const char*)input->src + input->pos; size_t readSize = input->size - input->pos; void* dst = (char*)output->dst + output->pos; size_t decodedSize = output->size - output->pos; size_t const hintSize = ZBUFFv06_decompressContinue(dctx, dst, &decodedSize, src, &readSize); output->pos += decodedSize; input->pos += readSize; return hintSize; } #endif #if (ZSTD_LEGACY_SUPPORT <= 7) case 7 : { ZBUFFv07_DCtx* dctx = (ZBUFFv07_DCtx*) legacyContext; const void* src = (const char*)input->src + input->pos; size_t readSize = input->size - input->pos; void* dst = (char*)output->dst + output->pos; size_t decodedSize = output->size - output->pos; size_t const hintSize = ZBUFFv07_decompressContinue(dctx, dst, &decodedSize, src, &readSize); output->pos += decodedSize; input->pos += readSize; return hintSize; } #endif } } #if defined (__cplusplus) } #endif #endif /* ZSTD_LEGACY_H */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_opt.c ================================================ /* * Copyright (c) 2016-present, Przemyslaw Skibinski, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #include "zstd_compress_internal.h" #include "zstd_opt.h" #define ZSTD_LITFREQ_ADD 2 /* scaling factor for litFreq, so that frequencies adapt faster to new stats. Also used for matchSum (?) */ #define ZSTD_FREQ_DIV 4 /* log factor when using previous stats to init next stats */ #define ZSTD_MAX_PRICE (1<<30) /*-************************************* * Price functions for optimal parser ***************************************/ static void ZSTD_setLog2Prices(optState_t* optPtr) { optPtr->log2litSum = ZSTD_highbit32(optPtr->litSum+1); optPtr->log2litLengthSum = ZSTD_highbit32(optPtr->litLengthSum+1); optPtr->log2matchLengthSum = ZSTD_highbit32(optPtr->matchLengthSum+1); optPtr->log2offCodeSum = ZSTD_highbit32(optPtr->offCodeSum+1); } static void ZSTD_rescaleFreqs(optState_t* const optPtr, const BYTE* const src, size_t const srcSize) { optPtr->staticPrices = 0; if (optPtr->litLengthSum == 0) { /* first init */ unsigned u; if (srcSize <= 1024) optPtr->staticPrices = 1; assert(optPtr->litFreq!=NULL); for (u=0; u<=MaxLit; u++) optPtr->litFreq[u] = 0; for (u=0; ulitFreq[src[u]]++; optPtr->litSum = 0; for (u=0; u<=MaxLit; u++) { optPtr->litFreq[u] = 1 + (optPtr->litFreq[u] >> ZSTD_FREQ_DIV); optPtr->litSum += optPtr->litFreq[u]; } for (u=0; u<=MaxLL; u++) optPtr->litLengthFreq[u] = 1; optPtr->litLengthSum = MaxLL+1; for (u=0; u<=MaxML; u++) optPtr->matchLengthFreq[u] = 1; optPtr->matchLengthSum = MaxML+1; for (u=0; u<=MaxOff; u++) optPtr->offCodeFreq[u] = 1; optPtr->offCodeSum = (MaxOff+1); } else { unsigned u; optPtr->litSum = 0; for (u=0; u<=MaxLit; u++) { optPtr->litFreq[u] = 1 + (optPtr->litFreq[u] >> (ZSTD_FREQ_DIV+1)); optPtr->litSum += optPtr->litFreq[u]; } optPtr->litLengthSum = 0; for (u=0; u<=MaxLL; u++) { optPtr->litLengthFreq[u] = 1 + (optPtr->litLengthFreq[u]>>(ZSTD_FREQ_DIV+1)); optPtr->litLengthSum += optPtr->litLengthFreq[u]; } optPtr->matchLengthSum = 0; for (u=0; u<=MaxML; u++) { optPtr->matchLengthFreq[u] = 1 + (optPtr->matchLengthFreq[u]>>ZSTD_FREQ_DIV); optPtr->matchLengthSum += optPtr->matchLengthFreq[u]; } optPtr->offCodeSum = 0; for (u=0; u<=MaxOff; u++) { optPtr->offCodeFreq[u] = 1 + (optPtr->offCodeFreq[u]>>ZSTD_FREQ_DIV); optPtr->offCodeSum += optPtr->offCodeFreq[u]; } } ZSTD_setLog2Prices(optPtr); } /* ZSTD_rawLiteralsCost() : * cost of literals (only) in given segment (which length can be null) * does not include cost of literalLength symbol */ static U32 ZSTD_rawLiteralsCost(const BYTE* const literals, U32 const litLength, const optState_t* const optPtr) { if (optPtr->staticPrices) return (litLength*6); /* 6 bit per literal - no statistic used */ if (litLength == 0) return 0; /* literals */ { U32 u; U32 cost = litLength * optPtr->log2litSum; for (u=0; u < litLength; u++) cost -= ZSTD_highbit32(optPtr->litFreq[literals[u]]+1); return cost; } } /* ZSTD_litLengthPrice() : * cost of literalLength symbol */ static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr) { if (optPtr->staticPrices) return ZSTD_highbit32((U32)litLength+1); /* literal Length */ { U32 const llCode = ZSTD_LLcode(litLength); U32 const price = LL_bits[llCode] + optPtr->log2litLengthSum - ZSTD_highbit32(optPtr->litLengthFreq[llCode]+1); return price; } } /* ZSTD_litLengthPrice() : * cost of the literal part of a sequence, * including literals themselves, and literalLength symbol */ static U32 ZSTD_fullLiteralsCost(const BYTE* const literals, U32 const litLength, const optState_t* const optPtr) { return ZSTD_rawLiteralsCost(literals, litLength, optPtr) + ZSTD_litLengthPrice(litLength, optPtr); } /* ZSTD_litLengthContribution() : * @return ( cost(litlength) - cost(0) ) * this value can then be added to rawLiteralsCost() * to provide a cost which is directly comparable to a match ending at same position */ static int ZSTD_litLengthContribution(U32 const litLength, const optState_t* const optPtr) { if (optPtr->staticPrices) return ZSTD_highbit32(litLength+1); /* literal Length */ { U32 const llCode = ZSTD_LLcode(litLength); int const contribution = LL_bits[llCode] + ZSTD_highbit32(optPtr->litLengthFreq[0]+1) - ZSTD_highbit32(optPtr->litLengthFreq[llCode]+1); #if 1 return contribution; #else return MAX(0, contribution); /* sometimes better, sometimes not ... */ #endif } } /* ZSTD_literalsContribution() : * creates a fake cost for the literals part of a sequence * which can be compared to the ending cost of a match * should a new match start at this position */ static int ZSTD_literalsContribution(const BYTE* const literals, U32 const litLength, const optState_t* const optPtr) { int const contribution = ZSTD_rawLiteralsCost(literals, litLength, optPtr) + ZSTD_litLengthContribution(litLength, optPtr); return contribution; } /* ZSTD_getMatchPrice() : * Provides the cost of the match part (offset + matchLength) of a sequence * Must be combined with ZSTD_fullLiteralsCost() to get the full cost of a sequence. * optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */ FORCE_INLINE_TEMPLATE U32 ZSTD_getMatchPrice( U32 const offset, U32 const matchLength, const optState_t* const optPtr, int const optLevel) { U32 price; U32 const offCode = ZSTD_highbit32(offset+1); U32 const mlBase = matchLength - MINMATCH; assert(matchLength >= MINMATCH); if (optPtr->staticPrices) /* fixed scheme, do not use statistics */ return ZSTD_highbit32((U32)mlBase+1) + 16 + offCode; price = offCode + optPtr->log2offCodeSum - ZSTD_highbit32(optPtr->offCodeFreq[offCode]+1); if ((optLevel<2) /*static*/ && offCode >= 20) price += (offCode-19)*2; /* handicap for long distance offsets, favor decompression speed */ /* match Length */ { U32 const mlCode = ZSTD_MLcode(mlBase); price += ML_bits[mlCode] + optPtr->log2matchLengthSum - ZSTD_highbit32(optPtr->matchLengthFreq[mlCode]+1); } DEBUGLOG(8, "ZSTD_getMatchPrice(ml:%u) = %u", matchLength, price); return price; } static void ZSTD_updateStats(optState_t* const optPtr, U32 litLength, const BYTE* literals, U32 offsetCode, U32 matchLength) { /* literals */ { U32 u; for (u=0; u < litLength; u++) optPtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD; optPtr->litSum += litLength*ZSTD_LITFREQ_ADD; } /* literal Length */ { U32 const llCode = ZSTD_LLcode(litLength); optPtr->litLengthFreq[llCode]++; optPtr->litLengthSum++; } /* match offset code (0-2=>repCode; 3+=>offset+2) */ { U32 const offCode = ZSTD_highbit32(offsetCode+1); assert(offCode <= MaxOff); optPtr->offCodeFreq[offCode]++; optPtr->offCodeSum++; } /* match Length */ { U32 const mlBase = matchLength - MINMATCH; U32 const mlCode = ZSTD_MLcode(mlBase); optPtr->matchLengthFreq[mlCode]++; optPtr->matchLengthSum++; } } /* ZSTD_readMINMATCH() : * function safe only for comparisons * assumption : memPtr must be at least 4 bytes before end of buffer */ MEM_STATIC U32 ZSTD_readMINMATCH(const void* memPtr, U32 length) { switch (length) { default : case 4 : return MEM_read32(memPtr); case 3 : if (MEM_isLittleEndian()) return MEM_read32(memPtr)<<8; else return MEM_read32(memPtr)>>8; } } /* Update hashTable3 up to ip (excluded) Assumption : always within prefix (i.e. not within extDict) */ static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_matchState_t* ms, const BYTE* const ip) { U32* const hashTable3 = ms->hashTable3; U32 const hashLog3 = ms->hashLog3; const BYTE* const base = ms->window.base; U32 idx = ms->nextToUpdate3; U32 const target = ms->nextToUpdate3 = (U32)(ip - base); size_t const hash3 = ZSTD_hash3Ptr(ip, hashLog3); assert(hashLog3 > 0); while(idx < target) { hashTable3[ZSTD_hash3Ptr(base+idx, hashLog3)] = idx; idx++; } return hashTable3[hash3]; } /*-************************************* * Binary Tree search ***************************************/ /** ZSTD_insertBt1() : add one or multiple positions to tree. * ip : assumed <= iend-8 . * @return : nb of positions added */ static U32 ZSTD_insertBt1( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* const ip, const BYTE* const iend, U32 const mls, U32 const extDict) { U32* const hashTable = ms->hashTable; U32 const hashLog = cParams->hashLog; size_t const h = ZSTD_hashPtr(ip, hashLog, mls); U32* const bt = ms->chainTable; U32 const btLog = cParams->chainLog - 1; U32 const btMask = (1 << btLog) - 1; U32 matchIndex = hashTable[h]; size_t commonLengthSmaller=0, commonLengthLarger=0; const BYTE* const base = ms->window.base; const BYTE* const dictBase = ms->window.dictBase; const U32 dictLimit = ms->window.dictLimit; const BYTE* const dictEnd = dictBase + dictLimit; const BYTE* const prefixStart = base + dictLimit; const BYTE* match; const U32 current = (U32)(ip-base); const U32 btLow = btMask >= current ? 0 : current - btMask; U32* smallerPtr = bt + 2*(current&btMask); U32* largerPtr = smallerPtr + 1; U32 dummy32; /* to be nullified at the end */ U32 const windowLow = ms->window.lowLimit; U32 matchEndIdx = current+8+1; size_t bestLength = 8; U32 nbCompares = 1U << cParams->searchLog; #ifdef ZSTD_C_PREDICT U32 predictedSmall = *(bt + 2*((current-1)&btMask) + 0); U32 predictedLarge = *(bt + 2*((current-1)&btMask) + 1); predictedSmall += (predictedSmall>0); predictedLarge += (predictedLarge>0); #endif /* ZSTD_C_PREDICT */ DEBUGLOG(8, "ZSTD_insertBt1 (%u)", current); assert(ip <= iend-8); /* required for h calculation */ hashTable[h] = current; /* Update Hash Table */ while (nbCompares-- && (matchIndex > windowLow)) { U32* const nextPtr = bt + 2*(matchIndex & btMask); size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */ assert(matchIndex < current); #ifdef ZSTD_C_PREDICT /* note : can create issues when hlog small <= 11 */ const U32* predictPtr = bt + 2*((matchIndex-1) & btMask); /* written this way, as bt is a roll buffer */ if (matchIndex == predictedSmall) { /* no need to check length, result known */ *smallerPtr = matchIndex; if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop the search */ smallerPtr = nextPtr+1; /* new "smaller" => larger of match */ matchIndex = nextPtr[1]; /* new matchIndex larger than previous (closer to current) */ predictedSmall = predictPtr[1] + (predictPtr[1]>0); continue; } if (matchIndex == predictedLarge) { *largerPtr = matchIndex; if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */ largerPtr = nextPtr; matchIndex = nextPtr[0]; predictedLarge = predictPtr[0] + (predictPtr[0]>0); continue; } #endif if ((!extDict) || (matchIndex+matchLength >= dictLimit)) { assert(matchIndex+matchLength >= dictLimit); /* might be wrong if extDict is incorrectly set to 0 */ match = base + matchIndex; matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend); } else { match = dictBase + matchIndex; matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart); if (matchIndex+matchLength >= dictLimit) match = base + matchIndex; /* to prepare for next usage of match[matchLength] */ } if (matchLength > bestLength) { bestLength = matchLength; if (matchLength > matchEndIdx - matchIndex) matchEndIdx = matchIndex + (U32)matchLength; } if (ip+matchLength == iend) { /* equal : no way to know if inf or sup */ break; /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */ } if (match[matchLength] < ip[matchLength]) { /* necessarily within buffer */ /* match is smaller than current */ *smallerPtr = matchIndex; /* update smaller idx */ commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */ if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop searching */ smallerPtr = nextPtr+1; /* new "candidate" => larger than match, which was smaller than target */ matchIndex = nextPtr[1]; /* new matchIndex, larger than previous and closer to current */ } else { /* match is larger than current */ *largerPtr = matchIndex; commonLengthLarger = matchLength; if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop searching */ largerPtr = nextPtr; matchIndex = nextPtr[0]; } } *smallerPtr = *largerPtr = 0; if (bestLength > 384) return MIN(192, (U32)(bestLength - 384)); /* speed optimization */ assert(matchEndIdx > current + 8); return matchEndIdx - (current + 8); } FORCE_INLINE_TEMPLATE void ZSTD_updateTree_internal( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* const ip, const BYTE* const iend, const U32 mls, const U32 extDict) { const BYTE* const base = ms->window.base; U32 const target = (U32)(ip - base); U32 idx = ms->nextToUpdate; DEBUGLOG(7, "ZSTD_updateTree_internal, from %u to %u (extDict:%u)", idx, target, extDict); while(idx < target) idx += ZSTD_insertBt1(ms, cParams, base+idx, iend, mls, extDict); ms->nextToUpdate = target; } void ZSTD_updateTree( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip, const BYTE* iend) { ZSTD_updateTree_internal(ms, cParams, ip, iend, cParams->searchLength, 0 /*extDict*/); } FORCE_INLINE_TEMPLATE U32 ZSTD_insertBtAndGetAllMatches ( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* const ip, const BYTE* const iLimit, int const extDict, U32 rep[ZSTD_REP_NUM], U32 const ll0, ZSTD_match_t* matches, const U32 lengthToBeat, U32 const mls /* template */) { U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1); const BYTE* const base = ms->window.base; U32 const current = (U32)(ip-base); U32 const hashLog = cParams->hashLog; U32 const minMatch = (mls==3) ? 3 : 4; U32* const hashTable = ms->hashTable; size_t const h = ZSTD_hashPtr(ip, hashLog, mls); U32 matchIndex = hashTable[h]; U32* const bt = ms->chainTable; U32 const btLog = cParams->chainLog - 1; U32 const btMask= (1U << btLog) - 1; size_t commonLengthSmaller=0, commonLengthLarger=0; const BYTE* const dictBase = ms->window.dictBase; U32 const dictLimit = ms->window.dictLimit; const BYTE* const dictEnd = dictBase + dictLimit; const BYTE* const prefixStart = base + dictLimit; U32 const btLow = btMask >= current ? 0 : current - btMask; U32 const windowLow = ms->window.lowLimit; U32* smallerPtr = bt + 2*(current&btMask); U32* largerPtr = bt + 2*(current&btMask) + 1; U32 matchEndIdx = current+8+1; /* farthest referenced position of any match => detects repetitive patterns */ U32 dummy32; /* to be nullified at the end */ U32 mnum = 0; U32 nbCompares = 1U << cParams->searchLog; size_t bestLength = lengthToBeat-1; DEBUGLOG(7, "ZSTD_insertBtAndGetAllMatches"); /* check repCode */ { U32 const lastR = ZSTD_REP_NUM + ll0; U32 repCode; for (repCode = ll0; repCode < lastR; repCode++) { U32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode]; U32 const repIndex = current - repOffset; U32 repLen = 0; assert(current >= dictLimit); if (repOffset-1 /* intentional overflow, discards 0 and -1 */ < current-dictLimit) { /* equivalent to `current > repIndex >= dictLimit` */ if (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch)) { repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iLimit) + minMatch; } } else { /* repIndex < dictLimit || repIndex >= current */ const BYTE* const repMatch = dictBase + repIndex; assert(current >= windowLow); if ( extDict /* this case only valid in extDict mode */ && ( ((repOffset-1) /*intentional overflow*/ < current - windowLow) /* equivalent to `current > repIndex >= windowLow` */ & (((U32)((dictLimit-1) - repIndex) >= 3) ) /* intentional overflow : do not test positions overlapping 2 memory segments */) && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) { repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dictEnd, prefixStart) + minMatch; } } /* save longer solution */ if (repLen > bestLength) { DEBUGLOG(8, "found rep-match %u of length %u", repCode - ll0, (U32)repLen); bestLength = repLen; matches[mnum].off = repCode - ll0; matches[mnum].len = (U32)repLen; mnum++; if ( (repLen > sufficient_len) | (ip+repLen == iLimit) ) { /* best possible */ return mnum; } } } } /* HC3 match finder */ if ((mls == 3) /*static*/ && (bestLength < mls)) { U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3(ms, ip); if ((matchIndex3 > windowLow) & (current - matchIndex3 < (1<<18)) /*heuristic : longer distance likely too expensive*/ ) { size_t mlen; if ((!extDict) /*static*/ || (matchIndex3 >= dictLimit)) { const BYTE* const match = base + matchIndex3; mlen = ZSTD_count(ip, match, iLimit); } else { const BYTE* const match = dictBase + matchIndex3; mlen = ZSTD_count_2segments(ip, match, iLimit, dictEnd, prefixStart); } /* save best solution */ if (mlen >= mls /* == 3 > bestLength */) { DEBUGLOG(8, "found small match with hlog3, of length %u", (U32)mlen); bestLength = mlen; assert(current > matchIndex3); assert(mnum==0); /* no prior solution */ matches[0].off = (current - matchIndex3) + ZSTD_REP_MOVE; matches[0].len = (U32)mlen; mnum = 1; if ( (mlen > sufficient_len) | (ip+mlen == iLimit) ) { /* best possible length */ ms->nextToUpdate = current+1; /* skip insertion */ return 1; } } } } hashTable[h] = current; /* Update Hash Table */ while (nbCompares-- && (matchIndex > windowLow)) { U32* const nextPtr = bt + 2*(matchIndex & btMask); size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */ const BYTE* match; assert(current > matchIndex); if ((!extDict) || (matchIndex+matchLength >= dictLimit)) { assert(matchIndex+matchLength >= dictLimit); /* ensure the condition is correct when !extDict */ match = base + matchIndex; matchLength += ZSTD_count(ip+matchLength, match+matchLength, iLimit); } else { match = dictBase + matchIndex; matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart); if (matchIndex+matchLength >= dictLimit) match = base + matchIndex; /* prepare for match[matchLength] */ } if (matchLength > bestLength) { DEBUGLOG(8, "found match of length %u at distance %u", (U32)matchLength, current - matchIndex); assert(matchEndIdx > matchIndex); if (matchLength > matchEndIdx - matchIndex) matchEndIdx = matchIndex + (U32)matchLength; bestLength = matchLength; matches[mnum].off = (current - matchIndex) + ZSTD_REP_MOVE; matches[mnum].len = (U32)matchLength; mnum++; if (matchLength > ZSTD_OPT_NUM) break; if (ip+matchLength == iLimit) { /* equal : no way to know if inf or sup */ break; /* drop, to preserve bt consistency (miss a little bit of compression) */ } } if (match[matchLength] < ip[matchLength]) { /* match smaller than current */ *smallerPtr = matchIndex; /* update smaller idx */ commonLengthSmaller = matchLength; /* all smaller will now have at least this guaranteed common length */ if (matchIndex <= btLow) { smallerPtr=&dummy32; break; } /* beyond tree size, stop the search */ smallerPtr = nextPtr+1; /* new candidate => larger than match, which was smaller than current */ matchIndex = nextPtr[1]; /* new matchIndex, larger than previous, closer to current */ } else { *largerPtr = matchIndex; commonLengthLarger = matchLength; if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */ largerPtr = nextPtr; matchIndex = nextPtr[0]; } } *smallerPtr = *largerPtr = 0; assert(matchEndIdx > current+8); ms->nextToUpdate = matchEndIdx - 8; /* skip repetitive patterns */ return mnum; } FORCE_INLINE_TEMPLATE U32 ZSTD_BtGetAllMatches ( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip, const BYTE* const iHighLimit, int const extDict, U32 rep[ZSTD_REP_NUM], U32 const ll0, ZSTD_match_t* matches, U32 const lengthToBeat) { U32 const matchLengthSearch = cParams->searchLength; DEBUGLOG(7, "ZSTD_BtGetAllMatches"); if (ip < ms->window.base + ms->nextToUpdate) return 0; /* skipped area */ ZSTD_updateTree_internal(ms, cParams, ip, iHighLimit, matchLengthSearch, extDict); switch(matchLengthSearch) { case 3 : return ZSTD_insertBtAndGetAllMatches(ms, cParams, ip, iHighLimit, extDict, rep, ll0, matches, lengthToBeat, 3); default : case 4 : return ZSTD_insertBtAndGetAllMatches(ms, cParams, ip, iHighLimit, extDict, rep, ll0, matches, lengthToBeat, 4); case 5 : return ZSTD_insertBtAndGetAllMatches(ms, cParams, ip, iHighLimit, extDict, rep, ll0, matches, lengthToBeat, 5); case 7 : case 6 : return ZSTD_insertBtAndGetAllMatches(ms, cParams, ip, iHighLimit, extDict, rep, ll0, matches, lengthToBeat, 6); } } /*-******************************* * Optimal parser *********************************/ typedef struct repcodes_s { U32 rep[3]; } repcodes_t; repcodes_t ZSTD_updateRep(U32 const rep[3], U32 const offset, U32 const ll0) { repcodes_t newReps; if (offset >= ZSTD_REP_NUM) { /* full offset */ newReps.rep[2] = rep[1]; newReps.rep[1] = rep[0]; newReps.rep[0] = offset - ZSTD_REP_MOVE; } else { /* repcode */ U32 const repCode = offset + ll0; if (repCode > 0) { /* note : if repCode==0, no change */ U32 const currentOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode]; newReps.rep[2] = (repCode >= 2) ? rep[1] : rep[2]; newReps.rep[1] = rep[0]; newReps.rep[0] = currentOffset; } else { /* repCode == 0 */ memcpy(&newReps, rep, sizeof(newReps)); } } return newReps; } typedef struct { const BYTE* anchor; U32 litlen; U32 rawLitCost; } cachedLiteralPrice_t; static U32 ZSTD_rawLiteralsCost_cached( cachedLiteralPrice_t* const cachedLitPrice, const BYTE* const anchor, U32 const litlen, const optState_t* const optStatePtr) { U32 startCost; U32 remainingLength; const BYTE* startPosition; if (anchor == cachedLitPrice->anchor) { startCost = cachedLitPrice->rawLitCost; startPosition = anchor + cachedLitPrice->litlen; assert(litlen >= cachedLitPrice->litlen); remainingLength = litlen - cachedLitPrice->litlen; } else { startCost = 0; startPosition = anchor; remainingLength = litlen; } { U32 const rawLitCost = startCost + ZSTD_rawLiteralsCost(startPosition, remainingLength, optStatePtr); cachedLitPrice->anchor = anchor; cachedLitPrice->litlen = litlen; cachedLitPrice->rawLitCost = rawLitCost; return rawLitCost; } } static U32 ZSTD_fullLiteralsCost_cached( cachedLiteralPrice_t* const cachedLitPrice, const BYTE* const anchor, U32 const litlen, const optState_t* const optStatePtr) { return ZSTD_rawLiteralsCost_cached(cachedLitPrice, anchor, litlen, optStatePtr) + ZSTD_litLengthPrice(litlen, optStatePtr); } static int ZSTD_literalsContribution_cached( cachedLiteralPrice_t* const cachedLitPrice, const BYTE* const anchor, U32 const litlen, const optState_t* const optStatePtr) { int const contribution = ZSTD_rawLiteralsCost_cached(cachedLitPrice, anchor, litlen, optStatePtr) + ZSTD_litLengthContribution(litlen, optStatePtr); return contribution; } FORCE_INLINE_TEMPLATE size_t ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, const void* src, size_t srcSize, const int optLevel, const int extDict) { optState_t* const optStatePtr = &ms->opt; const BYTE* const istart = (const BYTE*)src; const BYTE* ip = istart; const BYTE* anchor = istart; const BYTE* const iend = istart + srcSize; const BYTE* const ilimit = iend - 8; const BYTE* const base = ms->window.base; const BYTE* const prefixStart = base + ms->window.dictLimit; U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1); U32 const minMatch = (cParams->searchLength == 3) ? 3 : 4; ZSTD_optimal_t* const opt = optStatePtr->priceTable; ZSTD_match_t* const matches = optStatePtr->matchTable; cachedLiteralPrice_t cachedLitPrice; /* init */ DEBUGLOG(5, "ZSTD_compressBlock_opt_generic"); ms->nextToUpdate3 = ms->nextToUpdate; ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize); ip += (ip==prefixStart); memset(&cachedLitPrice, 0, sizeof(cachedLitPrice)); /* Match Loop */ while (ip < ilimit) { U32 cur, last_pos = 0; U32 best_mlen, best_off; /* find first match */ { U32 const litlen = (U32)(ip - anchor); U32 const ll0 = !litlen; U32 const nbMatches = ZSTD_BtGetAllMatches(ms, cParams, ip, iend, extDict, rep, ll0, matches, minMatch); if (!nbMatches) { ip++; continue; } /* initialize opt[0] */ { U32 i ; for (i=0; i immediate encoding */ { U32 const maxML = matches[nbMatches-1].len; DEBUGLOG(7, "found %u matches of maxLength=%u and offset=%u at cPos=%u => start new serie", nbMatches, maxML, matches[nbMatches-1].off, (U32)(ip-prefixStart)); if (maxML > sufficient_len) { best_mlen = maxML; best_off = matches[nbMatches-1].off; DEBUGLOG(7, "large match (%u>%u), immediate encoding", best_mlen, sufficient_len); cur = 0; last_pos = 1; goto _shortestPath; } } /* set prices for first matches starting position == 0 */ { U32 const literalsPrice = ZSTD_fullLiteralsCost_cached(&cachedLitPrice, anchor, litlen, optStatePtr); U32 pos; U32 matchNb; for (pos = 0; pos < minMatch; pos++) { opt[pos].mlen = 1; opt[pos].price = ZSTD_MAX_PRICE; } for (matchNb = 0; matchNb < nbMatches; matchNb++) { U32 const offset = matches[matchNb].off; U32 const end = matches[matchNb].len; repcodes_t const repHistory = ZSTD_updateRep(rep, offset, ll0); for ( ; pos <= end ; pos++ ) { U32 const matchPrice = literalsPrice + ZSTD_getMatchPrice(offset, pos, optStatePtr, optLevel); DEBUGLOG(7, "rPos:%u => set initial price : %u", pos, matchPrice); opt[pos].mlen = pos; opt[pos].off = offset; opt[pos].litlen = litlen; opt[pos].price = matchPrice; memcpy(opt[pos].rep, &repHistory, sizeof(repHistory)); } } last_pos = pos-1; } } /* check further positions */ for (cur = 1; cur <= last_pos; cur++) { const BYTE* const inr = ip + cur; assert(cur < ZSTD_OPT_NUM); /* Fix current position with one literal if cheaper */ { U32 const litlen = (opt[cur-1].mlen == 1) ? opt[cur-1].litlen + 1 : 1; int price; /* note : contribution can be negative */ if (cur > litlen) { price = opt[cur - litlen].price + ZSTD_literalsContribution(inr-litlen, litlen, optStatePtr); } else { price = ZSTD_literalsContribution_cached(&cachedLitPrice, anchor, litlen, optStatePtr); } assert(price < 1000000000); /* overflow check */ if (price <= opt[cur].price) { DEBUGLOG(7, "rPos:%u : better price (%u<%u) using literal", cur, price, opt[cur].price); opt[cur].mlen = 1; opt[cur].off = 0; opt[cur].litlen = litlen; opt[cur].price = price; memcpy(opt[cur].rep, opt[cur-1].rep, sizeof(opt[cur].rep)); } } /* last match must start at a minimum distance of 8 from oend */ if (inr > ilimit) continue; if (cur == last_pos) break; if ( (optLevel==0) /*static*/ && (opt[cur+1].price <= opt[cur].price) ) continue; /* skip unpromising positions; about ~+6% speed, -0.01 ratio */ { U32 const ll0 = (opt[cur].mlen != 1); U32 const litlen = (opt[cur].mlen == 1) ? opt[cur].litlen : 0; U32 const previousPrice = (cur > litlen) ? opt[cur-litlen].price : 0; U32 const basePrice = previousPrice + ZSTD_fullLiteralsCost(inr-litlen, litlen, optStatePtr); U32 const nbMatches = ZSTD_BtGetAllMatches(ms, cParams, inr, iend, extDict, opt[cur].rep, ll0, matches, minMatch); U32 matchNb; if (!nbMatches) continue; { U32 const maxML = matches[nbMatches-1].len; DEBUGLOG(7, "rPos:%u, found %u matches, of maxLength=%u", cur, nbMatches, maxML); if ( (maxML > sufficient_len) | (cur + maxML >= ZSTD_OPT_NUM) ) { best_mlen = maxML; best_off = matches[nbMatches-1].off; last_pos = cur + 1; goto _shortestPath; } } /* set prices using matches found at position == cur */ for (matchNb = 0; matchNb < nbMatches; matchNb++) { U32 const offset = matches[matchNb].off; repcodes_t const repHistory = ZSTD_updateRep(opt[cur].rep, offset, ll0); U32 const lastML = matches[matchNb].len; U32 const startML = (matchNb>0) ? matches[matchNb-1].len+1 : minMatch; U32 mlen; DEBUGLOG(7, "testing match %u => offCode=%u, mlen=%u, llen=%u", matchNb, matches[matchNb].off, lastML, litlen); for (mlen = lastML; mlen >= startML; mlen--) { U32 const pos = cur + mlen; int const price = basePrice + ZSTD_getMatchPrice(offset, mlen, optStatePtr, optLevel); if ((pos > last_pos) || (price < opt[pos].price)) { DEBUGLOG(7, "rPos:%u => new better price (%u<%u)", pos, price, opt[pos].price); while (last_pos < pos) { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; } opt[pos].mlen = mlen; opt[pos].off = offset; opt[pos].litlen = litlen; opt[pos].price = price; memcpy(opt[pos].rep, &repHistory, sizeof(repHistory)); } else { if (optLevel==0) break; /* gets ~+10% speed for about -0.01 ratio loss */ } } } } } /* for (cur = 1; cur <= last_pos; cur++) */ best_mlen = opt[last_pos].mlen; best_off = opt[last_pos].off; cur = last_pos - best_mlen; _shortestPath: /* cur, last_pos, best_mlen, best_off have to be set */ assert(opt[0].mlen == 1); /* reverse traversal */ DEBUGLOG(7, "start reverse traversal (last_pos:%u, cur:%u)", last_pos, cur); { U32 selectedMatchLength = best_mlen; U32 selectedOffset = best_off; U32 pos = cur; while (1) { U32 const mlen = opt[pos].mlen; U32 const off = opt[pos].off; opt[pos].mlen = selectedMatchLength; opt[pos].off = selectedOffset; selectedMatchLength = mlen; selectedOffset = off; if (mlen > pos) break; pos -= mlen; } } /* save sequences */ { U32 pos; for (pos=0; pos < last_pos; ) { U32 const llen = (U32)(ip - anchor); U32 const mlen = opt[pos].mlen; U32 const offset = opt[pos].off; if (mlen == 1) { ip++; pos++; continue; } /* literal position => move on */ pos += mlen; ip += mlen; /* repcodes update : like ZSTD_updateRep(), but update in place */ if (offset >= ZSTD_REP_NUM) { /* full offset */ rep[2] = rep[1]; rep[1] = rep[0]; rep[0] = offset - ZSTD_REP_MOVE; } else { /* repcode */ U32 const repCode = offset + (llen==0); if (repCode) { /* note : if repCode==0, no change */ U32 const currentOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode]; if (repCode >= 2) rep[2] = rep[1]; rep[1] = rep[0]; rep[0] = currentOffset; } } ZSTD_updateStats(optStatePtr, llen, anchor, offset, mlen); ZSTD_storeSeq(seqStore, llen, anchor, offset, mlen-MINMATCH); anchor = ip; } } ZSTD_setLog2Prices(optStatePtr); } /* while (ip < ilimit) */ /* Return the last literals size */ return iend - anchor; } size_t ZSTD_compressBlock_btopt( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { DEBUGLOG(5, "ZSTD_compressBlock_btopt"); return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, cParams, src, srcSize, 0 /*optLevel*/, 0 /*extDict*/); } size_t ZSTD_compressBlock_btultra( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, cParams, src, srcSize, 2 /*optLevel*/, 0 /*extDict*/); } size_t ZSTD_compressBlock_btopt_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, cParams, src, srcSize, 0 /*optLevel*/, 1 /*extDict*/); } size_t ZSTD_compressBlock_btultra_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize) { return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, cParams, src, srcSize, 2 /*optLevel*/, 1 /*extDict*/); } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_opt.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef ZSTD_OPT_H #define ZSTD_OPT_H #if defined (__cplusplus) extern "C" { #endif #include "zstd_compress_internal.h" void ZSTD_updateTree( ZSTD_matchState_t* ms, ZSTD_compressionParameters const* cParams, const BYTE* ip, const BYTE* iend); /* used in ZSTD_loadDictionaryContent() */ size_t ZSTD_compressBlock_btopt( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_btultra( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_btopt_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); size_t ZSTD_compressBlock_btultra_extDict( ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], ZSTD_compressionParameters const* cParams, void const* src, size_t srcSize); #if defined (__cplusplus) } #endif #endif /* ZSTD_OPT_H */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_stream.go ================================================ package zstd /* #define ZSTD_STATIC_LINKING_ONLY #define ZBUFF_DISABLE_DEPRECATE_WARNINGS #include "zstd.h" #include "zbuff.h" */ import "C" import ( "errors" "fmt" "io" "unsafe" ) var errShortRead = errors.New("short read") // Writer is an io.WriteCloser that zstd-compresses its input. type Writer struct { CompressionLevel int ctx *C.ZSTD_CCtx dict []byte dstBuffer []byte firstError error underlyingWriter io.Writer } func resize(in []byte, newSize int) []byte { if in == nil { return make([]byte, newSize) } if newSize <= cap(in) { return in[:newSize] } toAdd := newSize - len(in) return append(in, make([]byte, toAdd)...) } // NewWriter creates a new Writer with default compression options. Writes to // the writer will be written in compressed form to w. func NewWriter(w io.Writer) *Writer { return NewWriterLevelDict(w, DefaultCompression, nil) } // NewWriterLevel is like NewWriter but specifies the compression level instead // of assuming default compression. // // The level can be DefaultCompression or any integer value between BestSpeed // and BestCompression inclusive. func NewWriterLevel(w io.Writer, level int) *Writer { return NewWriterLevelDict(w, level, nil) } // NewWriterLevelDict is like NewWriterLevel but specifies a dictionary to // compress with. If the dictionary is empty or nil it is ignored. The dictionary // should not be modified until the writer is closed. func NewWriterLevelDict(w io.Writer, level int, dict []byte) *Writer { var err error ctx := C.ZSTD_createCCtx() if dict == nil { err = getError(int(C.ZSTD_compressBegin(ctx, C.int(level)))) } else { err = getError(int(C.ZSTD_compressBegin_usingDict( ctx, unsafe.Pointer(&dict[0]), C.size_t(len(dict)), C.int(level)))) } return &Writer{ CompressionLevel: level, ctx: ctx, dict: dict, dstBuffer: make([]byte, CompressBound(1024)), firstError: err, underlyingWriter: w, } } // Write writes a compressed form of p to the underlying io.Writer. func (w *Writer) Write(p []byte) (int, error) { if w.firstError != nil { return 0, w.firstError } if len(p) == 0 { return 0, nil } // Check if dstBuffer is enough if len(w.dstBuffer) < CompressBound(len(p)) { w.dstBuffer = make([]byte, CompressBound(len(p))) } retCode := C.ZSTD_compressContinue( w.ctx, unsafe.Pointer(&w.dstBuffer[0]), C.size_t(len(w.dstBuffer)), unsafe.Pointer(&p[0]), C.size_t(len(p))) if err := getError(int(retCode)); err != nil { return 0, err } written := int(retCode) // Write to underlying buffer _, err := w.underlyingWriter.Write(w.dstBuffer[:written]) // Same behaviour as zlib, we can't know how much data we wrote, only // if there was an error if err != nil { return 0, err } return len(p), err } // Close closes the Writer, flushing any unwritten data to the underlying // io.Writer and freeing objects, but does not close the underlying io.Writer. func (w *Writer) Close() error { retCode := C.ZSTD_compressEnd( w.ctx, unsafe.Pointer(&w.dstBuffer[0]), C.size_t(len(w.dstBuffer)), unsafe.Pointer(nil), C.size_t(0)) if err := getError(int(retCode)); err != nil { return err } written := int(retCode) retCode = C.ZSTD_freeCCtx(w.ctx) // Safely close buffer before writing the end if err := getError(int(retCode)); err != nil { return err } _, err := w.underlyingWriter.Write(w.dstBuffer[:written]) if err != nil { return err } return nil } // reader is an io.ReadCloser that decompresses when read from. type reader struct { ctx *C.ZBUFF_DCtx compressionBuffer []byte compressionLeft int decompressionBuffer []byte decompOff int decompSize int dict []byte firstError error recommendedSrcSize int underlyingReader io.Reader } // NewReader creates a new io.ReadCloser. Reads from the returned ReadCloser // read and decompress data from r. It is the caller's responsibility to call // Close on the ReadCloser when done. If this is not done, underlying objects // in the zstd library will not be freed. func NewReader(r io.Reader) io.ReadCloser { return NewReaderDict(r, nil) } // NewReaderDict is like NewReader but uses a preset dictionary. NewReaderDict // ignores the dictionary if it is nil. func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser { var err error ctx := C.ZBUFF_createDCtx() if len(dict) == 0 { err = getError(int(C.ZBUFF_decompressInit(ctx))) } else { err = getError(int(C.ZBUFF_decompressInitDictionary( ctx, unsafe.Pointer(&dict[0]), C.size_t(len(dict))))) } cSize := int(C.ZBUFF_recommendedDInSize()) dSize := int(C.ZBUFF_recommendedDOutSize()) if cSize <= 0 { panic(fmt.Errorf("ZBUFF_recommendedDInSize() returned invalid size: %v", cSize)) } if dSize <= 0 { panic(fmt.Errorf("ZBUFF_recommendedDOutSize() returned invalid size: %v", dSize)) } compressionBuffer := make([]byte, cSize) decompressionBuffer := make([]byte, dSize) return &reader{ ctx: ctx, dict: dict, compressionBuffer: compressionBuffer, decompressionBuffer: decompressionBuffer, firstError: err, recommendedSrcSize: cSize, underlyingReader: r, } } // Close frees the allocated C objects func (r *reader) Close() error { return getError(int(C.ZBUFF_freeDCtx(r.ctx))) } func (r *reader) Read(p []byte) (int, error) { // If we already have enough bytes, return if r.decompSize-r.decompOff >= len(p) { copy(p, r.decompressionBuffer[r.decompOff:]) r.decompOff += len(p) return len(p), nil } copy(p, r.decompressionBuffer[r.decompOff:r.decompSize]) got := r.decompSize - r.decompOff r.decompSize = 0 r.decompOff = 0 for got < len(p) { // Populate src src := r.compressionBuffer reader := r.underlyingReader n, err := TryReadFull(reader, src[r.compressionLeft:]) if err != nil && err != errShortRead { // Handle underlying reader errors first return 0, fmt.Errorf("failed to read from underlying reader: %s", err) } else if n == 0 && r.compressionLeft == 0 { return got, io.EOF } src = src[:r.compressionLeft+n] // C code cSrcSize := C.size_t(len(src)) cDstSize := C.size_t(len(r.decompressionBuffer)) retCode := int(C.ZBUFF_decompressContinue( r.ctx, unsafe.Pointer(&r.decompressionBuffer[0]), &cDstSize, unsafe.Pointer(&src[0]), &cSrcSize)) if err = getError(retCode); err != nil { return 0, fmt.Errorf("failed to decompress: %s", err) } // Put everything in buffer if int(cSrcSize) < len(src) { left := src[int(cSrcSize):] copy(r.compressionBuffer, left) } r.compressionLeft = len(src) - int(cSrcSize) r.decompSize = int(cDstSize) r.decompOff = copy(p[got:], r.decompressionBuffer[:r.decompSize]) got += r.decompOff // Resize buffers nsize := retCode // Hint for next src buffer size if nsize <= 0 { // Reset to recommended size nsize = r.recommendedSrcSize } if nsize < r.compressionLeft { nsize = r.compressionLeft } r.compressionBuffer = resize(r.compressionBuffer, nsize) } return got, nil } // TryReadFull reads buffer just as ReadFull does // Here we expect that buffer may end and we do not return ErrUnexpectedEOF as ReadAtLeast does. // We return errShortRead instead to distinguish short reads and failures. // We cannot use ReadFull/ReadAtLeast because it masks Reader errors, such as network failures // and causes panic instead of error. func TryReadFull(r io.Reader, buf []byte) (n int, err error) { for n < len(buf) && err == nil { var nn int nn, err = r.Read(buf[n:]) n += nn } if n == len(buf) && err == io.EOF { err = nil // EOF at the end is somewhat expected } else if err == io.EOF { err = errShortRead } return } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_v01.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ /****************************************** * Includes ******************************************/ #include /* size_t, ptrdiff_t */ #include "zstd_v01.h" #include "error_private.h" /****************************************** * Static allocation ******************************************/ /* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */ #define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1<2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.) * Increasing memory usage improves compression ratio * Reduced memory usage can improve speed, due to cache effect * Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */ #define FSE_MAX_MEMORY_USAGE 14 #define FSE_DEFAULT_MEMORY_USAGE 13 /* FSE_MAX_SYMBOL_VALUE : * Maximum symbol value authorized. * Required for proper stack allocation */ #define FSE_MAX_SYMBOL_VALUE 255 /**************************************************************** * template functions type & suffix ****************************************************************/ #define FSE_FUNCTION_TYPE BYTE #define FSE_FUNCTION_EXTENSION /**************************************************************** * Byte symbol type ****************************************************************/ typedef struct { unsigned short newState; unsigned char symbol; unsigned char nbBits; } FSE_decode_t; /* size == U32 */ /**************************************************************** * Compiler specifics ****************************************************************/ #ifdef _MSC_VER /* Visual Studio */ # define FORCE_INLINE static __forceinline # include /* For Visual 2005 */ # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ # pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */ #else # define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) # if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ # ifdef __GNUC__ # define FORCE_INLINE static inline __attribute__((always_inline)) # else # define FORCE_INLINE static inline # endif # else # define FORCE_INLINE static # endif /* __STDC_VERSION__ */ #endif /**************************************************************** * Includes ****************************************************************/ #include /* malloc, free, qsort */ #include /* memcpy, memset */ #include /* printf (debug) */ #ifndef MEM_ACCESS_MODULE #define MEM_ACCESS_MODULE /**************************************************************** * Basic Types *****************************************************************/ #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ # include typedef uint8_t BYTE; typedef uint16_t U16; typedef int16_t S16; typedef uint32_t U32; typedef int32_t S32; typedef uint64_t U64; typedef int64_t S64; #else typedef unsigned char BYTE; typedef unsigned short U16; typedef signed short S16; typedef unsigned int U32; typedef signed int S32; typedef unsigned long long U64; typedef signed long long S64; #endif #endif /* MEM_ACCESS_MODULE */ /**************************************************************** * Memory I/O *****************************************************************/ /* FSE_FORCE_MEMORY_ACCESS * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable. * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal. * The below switch allow to select different access method for improved performance. * Method 0 (default) : use `memcpy()`. Safe and portable. * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable). * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`. * Method 2 : direct access. This method is portable but violate C standard. * It can generate buggy code on targets generating assembly depending on alignment. * But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details. * Prefer these methods in priority order (0 > 1 > 2) */ #ifndef FSE_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */ # if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) ) # define FSE_FORCE_MEMORY_ACCESS 2 # elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \ (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) )) # define FSE_FORCE_MEMORY_ACCESS 1 # endif #endif static unsigned FSE_32bits(void) { return sizeof(void*)==4; } static unsigned FSE_isLittleEndian(void) { const union { U32 i; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */ return one.c[0]; } #if defined(FSE_FORCE_MEMORY_ACCESS) && (FSE_FORCE_MEMORY_ACCESS==2) static U16 FSE_read16(const void* memPtr) { return *(const U16*) memPtr; } static U32 FSE_read32(const void* memPtr) { return *(const U32*) memPtr; } static U64 FSE_read64(const void* memPtr) { return *(const U64*) memPtr; } #elif defined(FSE_FORCE_MEMORY_ACCESS) && (FSE_FORCE_MEMORY_ACCESS==1) /* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */ /* currently only defined for gcc and icc */ typedef union { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign; static U16 FSE_read16(const void* ptr) { return ((const unalign*)ptr)->u16; } static U32 FSE_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } static U64 FSE_read64(const void* ptr) { return ((const unalign*)ptr)->u64; } #else static U16 FSE_read16(const void* memPtr) { U16 val; memcpy(&val, memPtr, sizeof(val)); return val; } static U32 FSE_read32(const void* memPtr) { U32 val; memcpy(&val, memPtr, sizeof(val)); return val; } static U64 FSE_read64(const void* memPtr) { U64 val; memcpy(&val, memPtr, sizeof(val)); return val; } #endif // FSE_FORCE_MEMORY_ACCESS static U16 FSE_readLE16(const void* memPtr) { if (FSE_isLittleEndian()) return FSE_read16(memPtr); else { const BYTE* p = (const BYTE*)memPtr; return (U16)(p[0] + (p[1]<<8)); } } static U32 FSE_readLE32(const void* memPtr) { if (FSE_isLittleEndian()) return FSE_read32(memPtr); else { const BYTE* p = (const BYTE*)memPtr; return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24)); } } static U64 FSE_readLE64(const void* memPtr) { if (FSE_isLittleEndian()) return FSE_read64(memPtr); else { const BYTE* p = (const BYTE*)memPtr; return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24) + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56)); } } static size_t FSE_readLEST(const void* memPtr) { if (FSE_32bits()) return (size_t)FSE_readLE32(memPtr); else return (size_t)FSE_readLE64(memPtr); } /**************************************************************** * Constants *****************************************************************/ #define FSE_MAX_TABLELOG (FSE_MAX_MEMORY_USAGE-2) #define FSE_MAX_TABLESIZE (1U< FSE_TABLELOG_ABSOLUTE_MAX #error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported" #endif /**************************************************************** * Error Management ****************************************************************/ #define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ /**************************************************************** * Complex types ****************************************************************/ typedef struct { int deltaFindState; U32 deltaNbBits; } FSE_symbolCompressionTransform; /* total 8 bytes */ typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)]; /**************************************************************** * Internal functions ****************************************************************/ FORCE_INLINE unsigned FSE_highbit32 (U32 val) { # if defined(_MSC_VER) /* Visual */ unsigned long r; _BitScanReverse ( &r, val ); return (unsigned) r; # elif defined(__GNUC__) && (GCC_VERSION >= 304) /* GCC Intrinsic */ return 31 - __builtin_clz (val); # else /* Software version */ static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; U32 v = val; unsigned r; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; return r; # endif } /**************************************************************** * Templates ****************************************************************/ /* designed to be included for type-specific functions (template emulation in C) Objective is to write these functions only once, for improved maintenance */ /* safety checks */ #ifndef FSE_FUNCTION_EXTENSION # error "FSE_FUNCTION_EXTENSION must be defined" #endif #ifndef FSE_FUNCTION_TYPE # error "FSE_FUNCTION_TYPE must be defined" #endif /* Function names */ #define FSE_CAT(X,Y) X##Y #define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y) #define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y) static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; } #define FSE_DECODE_TYPE FSE_decode_t typedef struct { U16 tableLog; U16 fastMode; } FSE_DTableHeader; /* sizeof U32 */ static size_t FSE_buildDTable (FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) { void* ptr = dt; FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)(ptr) + 1; /* because dt is unsigned, 32-bits aligned on 32-bits */ const U32 tableSize = 1 << tableLog; const U32 tableMask = tableSize-1; const U32 step = FSE_tableStep(tableSize); U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1]; U32 position = 0; U32 highThreshold = tableSize-1; const S16 largeLimit= (S16)(1 << (tableLog-1)); U32 noLarge = 1; U32 s; /* Sanity Checks */ if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return (size_t)-FSE_ERROR_maxSymbolValue_tooLarge; if (tableLog > FSE_MAX_TABLELOG) return (size_t)-FSE_ERROR_tableLog_tooLarge; /* Init, lay down lowprob symbols */ DTableH[0].tableLog = (U16)tableLog; for (s=0; s<=maxSymbolValue; s++) { if (normalizedCounter[s]==-1) { tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s; symbolNext[s] = 1; } else { if (normalizedCounter[s] >= largeLimit) noLarge=0; symbolNext[s] = normalizedCounter[s]; } } /* Spread symbols */ for (s=0; s<=maxSymbolValue; s++) { int i; for (i=0; i highThreshold) position = (position + step) & tableMask; /* lowprob area */ } } if (position!=0) return (size_t)-FSE_ERROR_GENERIC; /* position must reach all cells once, otherwise normalizedCounter is incorrect */ /* Build Decoding table */ { U32 i; for (i=0; ifastMode = (U16)noLarge; return 0; } /****************************************** * FSE byte symbol ******************************************/ #ifndef FSE_COMMONDEFS_ONLY static unsigned FSE_isError(size_t code) { return (code > (size_t)(-FSE_ERROR_maxCode)); } static short FSE_abs(short a) { return a<0? -a : a; } /**************************************************************** * Header bitstream management ****************************************************************/ static size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr, const void* headerBuffer, size_t hbSize) { const BYTE* const istart = (const BYTE*) headerBuffer; const BYTE* const iend = istart + hbSize; const BYTE* ip = istart; int nbBits; int remaining; int threshold; U32 bitStream; int bitCount; unsigned charnum = 0; int previous0 = 0; if (hbSize < 4) return (size_t)-FSE_ERROR_srcSize_wrong; bitStream = FSE_readLE32(ip); nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG; /* extract tableLog */ if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return (size_t)-FSE_ERROR_tableLog_tooLarge; bitStream >>= 4; bitCount = 4; *tableLogPtr = nbBits; remaining = (1<1) && (charnum<=*maxSVPtr)) { if (previous0) { unsigned n0 = charnum; while ((bitStream & 0xFFFF) == 0xFFFF) { n0+=24; if (ip < iend-5) { ip+=2; bitStream = FSE_readLE32(ip) >> bitCount; } else { bitStream >>= 16; bitCount+=16; } } while ((bitStream & 3) == 3) { n0+=3; bitStream>>=2; bitCount+=2; } n0 += bitStream & 3; bitCount += 2; if (n0 > *maxSVPtr) return (size_t)-FSE_ERROR_maxSymbolValue_tooSmall; while (charnum < n0) normalizedCounter[charnum++] = 0; if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { ip += bitCount>>3; bitCount &= 7; bitStream = FSE_readLE32(ip) >> bitCount; } else bitStream >>= 2; } { const short max = (short)((2*threshold-1)-remaining); short count; if ((bitStream & (threshold-1)) < (U32)max) { count = (short)(bitStream & (threshold-1)); bitCount += nbBits-1; } else { count = (short)(bitStream & (2*threshold-1)); if (count >= threshold) count -= max; bitCount += nbBits; } count--; /* extra accuracy */ remaining -= FSE_abs(count); normalizedCounter[charnum++] = count; previous0 = !count; while (remaining < threshold) { nbBits--; threshold >>= 1; } { if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { ip += bitCount>>3; bitCount &= 7; } else { bitCount -= (int)(8 * (iend - 4 - ip)); ip = iend - 4; } bitStream = FSE_readLE32(ip) >> (bitCount & 31); } } } if (remaining != 1) return (size_t)-FSE_ERROR_GENERIC; *maxSVPtr = charnum-1; ip += (bitCount+7)>>3; if ((size_t)(ip-istart) > hbSize) return (size_t)-FSE_ERROR_srcSize_wrong; return ip-istart; } /********************************************************* * Decompression (Byte symbols) *********************************************************/ static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue) { void* ptr = dt; FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1; /* because dt is unsigned */ DTableH->tableLog = 0; DTableH->fastMode = 0; cell->newState = 0; cell->symbol = symbolValue; cell->nbBits = 0; return 0; } static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits) { void* ptr = dt; FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1; /* because dt is unsigned */ const unsigned tableSize = 1 << nbBits; const unsigned tableMask = tableSize - 1; const unsigned maxSymbolValue = tableMask; unsigned s; /* Sanity checks */ if (nbBits < 1) return (size_t)-FSE_ERROR_GENERIC; /* min size */ /* Build Decoding Table */ DTableH->tableLog = (U16)nbBits; DTableH->fastMode = 1; for (s=0; s<=maxSymbolValue; s++) { dinfo[s].newState = 0; dinfo[s].symbol = (BYTE)s; dinfo[s].nbBits = (BYTE)nbBits; } return 0; } /* FSE_initDStream * Initialize a FSE_DStream_t. * srcBuffer must point at the beginning of an FSE block. * The function result is the size of the FSE_block (== srcSize). * If srcSize is too small, the function will return an errorCode; */ static size_t FSE_initDStream(FSE_DStream_t* bitD, const void* srcBuffer, size_t srcSize) { if (srcSize < 1) return (size_t)-FSE_ERROR_srcSize_wrong; if (srcSize >= sizeof(size_t)) { U32 contain32; bitD->start = (const char*)srcBuffer; bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(size_t); bitD->bitContainer = FSE_readLEST(bitD->ptr); contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; if (contain32 == 0) return (size_t)-FSE_ERROR_GENERIC; /* stop bit not present */ bitD->bitsConsumed = 8 - FSE_highbit32(contain32); } else { U32 contain32; bitD->start = (const char*)srcBuffer; bitD->ptr = bitD->start; bitD->bitContainer = *(const BYTE*)(bitD->start); switch(srcSize) { case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16); case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24); case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32); case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) << 8; default:; } contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; if (contain32 == 0) return (size_t)-FSE_ERROR_GENERIC; /* stop bit not present */ bitD->bitsConsumed = 8 - FSE_highbit32(contain32); bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8; } return srcSize; } /*!FSE_lookBits * Provides next n bits from the bitContainer. * bitContainer is not modified (bits are still present for next read/look) * On 32-bits, maxNbBits==25 * On 64-bits, maxNbBits==57 * return : value extracted. */ static size_t FSE_lookBits(FSE_DStream_t* bitD, U32 nbBits) { const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask); } static size_t FSE_lookBitsFast(FSE_DStream_t* bitD, U32 nbBits) /* only if nbBits >= 1 !! */ { const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask); } static void FSE_skipBits(FSE_DStream_t* bitD, U32 nbBits) { bitD->bitsConsumed += nbBits; } /*!FSE_readBits * Read next n bits from the bitContainer. * On 32-bits, don't read more than maxNbBits==25 * On 64-bits, don't read more than maxNbBits==57 * Use the fast variant *only* if n >= 1. * return : value extracted. */ static size_t FSE_readBits(FSE_DStream_t* bitD, U32 nbBits) { size_t value = FSE_lookBits(bitD, nbBits); FSE_skipBits(bitD, nbBits); return value; } static size_t FSE_readBitsFast(FSE_DStream_t* bitD, U32 nbBits) /* only if nbBits >= 1 !! */ { size_t value = FSE_lookBitsFast(bitD, nbBits); FSE_skipBits(bitD, nbBits); return value; } static unsigned FSE_reloadDStream(FSE_DStream_t* bitD) { if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* should never happen */ return FSE_DStream_tooFar; if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) { bitD->ptr -= bitD->bitsConsumed >> 3; bitD->bitsConsumed &= 7; bitD->bitContainer = FSE_readLEST(bitD->ptr); return FSE_DStream_unfinished; } if (bitD->ptr == bitD->start) { if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return FSE_DStream_endOfBuffer; return FSE_DStream_completed; } { U32 nbBytes = bitD->bitsConsumed >> 3; U32 result = FSE_DStream_unfinished; if (bitD->ptr - nbBytes < bitD->start) { nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ result = FSE_DStream_endOfBuffer; } bitD->ptr -= nbBytes; bitD->bitsConsumed -= nbBytes*8; bitD->bitContainer = FSE_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD) */ return result; } } static void FSE_initDState(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD, const FSE_DTable* dt) { const void* ptr = dt; const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr; DStatePtr->state = FSE_readBits(bitD, DTableH->tableLog); FSE_reloadDStream(bitD); DStatePtr->table = dt + 1; } static BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD) { const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; const U32 nbBits = DInfo.nbBits; BYTE symbol = DInfo.symbol; size_t lowBits = FSE_readBits(bitD, nbBits); DStatePtr->state = DInfo.newState + lowBits; return symbol; } static BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD) { const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; const U32 nbBits = DInfo.nbBits; BYTE symbol = DInfo.symbol; size_t lowBits = FSE_readBitsFast(bitD, nbBits); DStatePtr->state = DInfo.newState + lowBits; return symbol; } /* FSE_endOfDStream Tells if bitD has reached end of bitStream or not */ static unsigned FSE_endOfDStream(const FSE_DStream_t* bitD) { return ((bitD->ptr == bitD->start) && (bitD->bitsConsumed == sizeof(bitD->bitContainer)*8)); } static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr) { return DStatePtr->state == 0; } FORCE_INLINE size_t FSE_decompress_usingDTable_generic( void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt, const unsigned fast) { BYTE* const ostart = (BYTE*) dst; BYTE* op = ostart; BYTE* const omax = op + maxDstSize; BYTE* const olimit = omax-3; FSE_DStream_t bitD; FSE_DState_t state1; FSE_DState_t state2; size_t errorCode; /* Init */ errorCode = FSE_initDStream(&bitD, cSrc, cSrcSize); /* replaced last arg by maxCompressed Size */ if (FSE_isError(errorCode)) return errorCode; FSE_initDState(&state1, &bitD, dt); FSE_initDState(&state2, &bitD, dt); #define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD) /* 4 symbols per loop */ for ( ; (FSE_reloadDStream(&bitD)==FSE_DStream_unfinished) && (op sizeof(bitD.bitContainer)*8) /* This test must be static */ FSE_reloadDStream(&bitD); op[1] = FSE_GETSYMBOL(&state2); if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */ { if (FSE_reloadDStream(&bitD) > FSE_DStream_unfinished) { op+=2; break; } } op[2] = FSE_GETSYMBOL(&state1); if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */ FSE_reloadDStream(&bitD); op[3] = FSE_GETSYMBOL(&state2); } /* tail */ /* note : FSE_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly FSE_DStream_completed */ while (1) { if ( (FSE_reloadDStream(&bitD)>FSE_DStream_completed) || (op==omax) || (FSE_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) ) break; *op++ = FSE_GETSYMBOL(&state1); if ( (FSE_reloadDStream(&bitD)>FSE_DStream_completed) || (op==omax) || (FSE_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) ) break; *op++ = FSE_GETSYMBOL(&state2); } /* end ? */ if (FSE_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2)) return op-ostart; if (op==omax) return (size_t)-FSE_ERROR_dstSize_tooSmall; /* dst buffer is full, but cSrc unfinished */ return (size_t)-FSE_ERROR_corruptionDetected; } static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt) { FSE_DTableHeader DTableH; memcpy(&DTableH, dt, sizeof(DTableH)); /* memcpy() into local variable, to avoid strict aliasing warning */ /* select fast mode (static) */ if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); } static size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize) { const BYTE* const istart = (const BYTE*)cSrc; const BYTE* ip = istart; short counting[FSE_MAX_SYMBOL_VALUE+1]; DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */ unsigned tableLog; unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE; size_t errorCode; if (cSrcSize<2) return (size_t)-FSE_ERROR_srcSize_wrong; /* too small input size */ /* normal FSE decoding mode */ errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); if (FSE_isError(errorCode)) return errorCode; if (errorCode >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong; /* too small input size */ ip += errorCode; cSrcSize -= errorCode; errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog); if (FSE_isError(errorCode)) return errorCode; /* always return, even if it is an error code */ return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt); } /* ******************************************************* * Huff0 : Huffman block compression *********************************************************/ #define HUF_MAX_SYMBOL_VALUE 255 #define HUF_DEFAULT_TABLELOG 12 /* used by default, when not specified */ #define HUF_MAX_TABLELOG 12 /* max possible tableLog; for allocation purpose; can be modified */ #define HUF_ABSOLUTEMAX_TABLELOG 16 /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */ #if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG) # error "HUF_MAX_TABLELOG is too large !" #endif typedef struct HUF_CElt_s { U16 val; BYTE nbBits; } HUF_CElt ; typedef struct nodeElt_s { U32 count; U16 parent; BYTE byte; BYTE nbBits; } nodeElt; /* ******************************************************* * Huff0 : Huffman block decompression *********************************************************/ typedef struct { BYTE byte; BYTE nbBits; } HUF_DElt; static size_t HUF_readDTable (U16* DTable, const void* src, size_t srcSize) { BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1]; U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; /* large enough for values from 0 to 16 */ U32 weightTotal; U32 maxBits; const BYTE* ip = (const BYTE*) src; size_t iSize; size_t oSize; U32 n; U32 nextRankStart; void* ptr = DTable+1; HUF_DElt* const dt = (HUF_DElt*)ptr; if (!srcSize) return (size_t)-FSE_ERROR_srcSize_wrong; iSize = ip[0]; FSE_STATIC_ASSERT(sizeof(HUF_DElt) == sizeof(U16)); /* if compilation fails here, assertion is false */ //memset(huffWeight, 0, sizeof(huffWeight)); /* should not be necessary, but some analyzer complain ... */ if (iSize >= 128) /* special header */ { if (iSize >= (242)) /* RLE */ { static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 }; oSize = l[iSize-242]; memset(huffWeight, 1, sizeof(huffWeight)); iSize = 0; } else /* Incompressible */ { oSize = iSize - 127; iSize = ((oSize+1)/2); if (iSize+1 > srcSize) return (size_t)-FSE_ERROR_srcSize_wrong; ip += 1; for (n=0; n> 4; huffWeight[n+1] = ip[n/2] & 15; } } } else /* header compressed with FSE (normal case) */ { if (iSize+1 > srcSize) return (size_t)-FSE_ERROR_srcSize_wrong; oSize = FSE_decompress(huffWeight, HUF_MAX_SYMBOL_VALUE, ip+1, iSize); /* max 255 values decoded, last one is implied */ if (FSE_isError(oSize)) return oSize; } /* collect weight stats */ memset(rankVal, 0, sizeof(rankVal)); weightTotal = 0; for (n=0; n= HUF_ABSOLUTEMAX_TABLELOG) return (size_t)-FSE_ERROR_corruptionDetected; rankVal[huffWeight[n]]++; weightTotal += (1 << huffWeight[n]) >> 1; } if (weightTotal == 0) return (size_t)-FSE_ERROR_corruptionDetected; /* get last non-null symbol weight (implied, total must be 2^n) */ maxBits = FSE_highbit32(weightTotal) + 1; if (maxBits > DTable[0]) return (size_t)-FSE_ERROR_tableLog_tooLarge; /* DTable is too small */ DTable[0] = (U16)maxBits; { U32 total = 1 << maxBits; U32 rest = total - weightTotal; U32 verif = 1 << FSE_highbit32(rest); U32 lastWeight = FSE_highbit32(rest) + 1; if (verif != rest) return (size_t)-FSE_ERROR_corruptionDetected; /* last value must be a clean power of 2 */ huffWeight[oSize] = (BYTE)lastWeight; rankVal[lastWeight]++; } /* check tree construction validity */ if ((rankVal[1] < 2) || (rankVal[1] & 1)) return (size_t)-FSE_ERROR_corruptionDetected; /* by construction : at least 2 elts of rank 1, must be even */ /* Prepare ranks */ nextRankStart = 0; for (n=1; n<=maxBits; n++) { U32 current = nextRankStart; nextRankStart += (rankVal[n] << (n-1)); rankVal[n] = current; } /* fill DTable */ for (n=0; n<=oSize; n++) { const U32 w = huffWeight[n]; const U32 length = (1 << w) >> 1; U32 i; HUF_DElt D; D.byte = (BYTE)n; D.nbBits = (BYTE)(maxBits + 1 - w); for (i = rankVal[w]; i < rankVal[w] + length; i++) dt[i] = D; rankVal[w] += length; } return iSize+1; } static BYTE HUF_decodeSymbol(FSE_DStream_t* Dstream, const HUF_DElt* dt, const U32 dtLog) { const size_t val = FSE_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ const BYTE c = dt[val].byte; FSE_skipBits(Dstream, dt[val].nbBits); return c; } static size_t HUF_decompress_usingDTable( /* -3% slower when non static */ void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const U16* DTable) { BYTE* const ostart = (BYTE*) dst; BYTE* op = ostart; BYTE* const omax = op + maxDstSize; BYTE* const olimit = omax-15; const void* ptr = DTable; const HUF_DElt* const dt = (const HUF_DElt*)(ptr)+1; const U32 dtLog = DTable[0]; size_t errorCode; U32 reloadStatus; /* Init */ const U16* jumpTable = (const U16*)cSrc; const size_t length1 = FSE_readLE16(jumpTable); const size_t length2 = FSE_readLE16(jumpTable+1); const size_t length3 = FSE_readLE16(jumpTable+2); const size_t length4 = cSrcSize - 6 - length1 - length2 - length3; // check coherency !! const char* const start1 = (const char*)(cSrc) + 6; const char* const start2 = start1 + length1; const char* const start3 = start2 + length2; const char* const start4 = start3 + length3; FSE_DStream_t bitD1, bitD2, bitD3, bitD4; if (length1+length2+length3+6 >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong; errorCode = FSE_initDStream(&bitD1, start1, length1); if (FSE_isError(errorCode)) return errorCode; errorCode = FSE_initDStream(&bitD2, start2, length2); if (FSE_isError(errorCode)) return errorCode; errorCode = FSE_initDStream(&bitD3, start3, length3); if (FSE_isError(errorCode)) return errorCode; errorCode = FSE_initDStream(&bitD4, start4, length4); if (FSE_isError(errorCode)) return errorCode; reloadStatus=FSE_reloadDStream(&bitD2); /* 16 symbols per loop */ for ( ; (reloadStatus12)) FSE_reloadDStream(&Dstream) #define HUF_DECODE_SYMBOL_2(n, Dstream) \ op[n] = HUF_decodeSymbol(&Dstream, dt, dtLog); \ if (FSE_32bits()) FSE_reloadDStream(&Dstream) HUF_DECODE_SYMBOL_1( 0, bitD1); HUF_DECODE_SYMBOL_1( 1, bitD2); HUF_DECODE_SYMBOL_1( 2, bitD3); HUF_DECODE_SYMBOL_1( 3, bitD4); HUF_DECODE_SYMBOL_2( 4, bitD1); HUF_DECODE_SYMBOL_2( 5, bitD2); HUF_DECODE_SYMBOL_2( 6, bitD3); HUF_DECODE_SYMBOL_2( 7, bitD4); HUF_DECODE_SYMBOL_1( 8, bitD1); HUF_DECODE_SYMBOL_1( 9, bitD2); HUF_DECODE_SYMBOL_1(10, bitD3); HUF_DECODE_SYMBOL_1(11, bitD4); HUF_DECODE_SYMBOL_0(12, bitD1); HUF_DECODE_SYMBOL_0(13, bitD2); HUF_DECODE_SYMBOL_0(14, bitD3); HUF_DECODE_SYMBOL_0(15, bitD4); } if (reloadStatus!=FSE_DStream_completed) /* not complete : some bitStream might be FSE_DStream_unfinished */ return (size_t)-FSE_ERROR_corruptionDetected; /* tail */ { // bitTail = bitD1; // *much* slower : -20% !??! FSE_DStream_t bitTail; bitTail.ptr = bitD1.ptr; bitTail.bitsConsumed = bitD1.bitsConsumed; bitTail.bitContainer = bitD1.bitContainer; // required in case of FSE_DStream_endOfBuffer bitTail.start = start1; for ( ; (FSE_reloadDStream(&bitTail) < FSE_DStream_completed) && (op= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong; ip += errorCode; cSrcSize -= errorCode; return HUF_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, DTable); } #endif /* FSE_COMMONDEFS_ONLY */ /* zstd - standard compression library Copyright (C) 2014-2015, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - zstd source repository : https://github.com/Cyan4973/zstd - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c */ /**************************************************************** * Tuning parameters *****************************************************************/ /* MEMORY_USAGE : * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.) * Increasing memory usage improves compression ratio * Reduced memory usage can improve speed, due to cache effect */ #define ZSTD_MEMORY_USAGE 17 /************************************** CPU Feature Detection **************************************/ /* * Automated efficient unaligned memory access detection * Based on known hardware architectures * This list will be updated thanks to feedbacks */ #if defined(CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS) \ || defined(__ARM_FEATURE_UNALIGNED) \ || defined(__i386__) || defined(__x86_64__) \ || defined(_M_IX86) || defined(_M_X64) \ || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_8__) \ || (defined(_M_ARM) && (_M_ARM >= 7)) # define ZSTD_UNALIGNED_ACCESS 1 #else # define ZSTD_UNALIGNED_ACCESS 0 #endif /******************************************************** * Includes *********************************************************/ #include /* calloc */ #include /* memcpy, memmove */ #include /* debug : printf */ /******************************************************** * Compiler specifics *********************************************************/ #ifdef __AVX2__ # include /* AVX2 intrinsics */ #endif #ifdef _MSC_VER /* Visual Studio */ # include /* For Visual 2005 */ # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ # pragma warning(disable : 4324) /* disable: C4324: padded structure */ #endif #ifndef MEM_ACCESS_MODULE #define MEM_ACCESS_MODULE /******************************************************** * Basic Types *********************************************************/ #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ # include typedef uint8_t BYTE; typedef uint16_t U16; typedef int16_t S16; typedef uint32_t U32; typedef int32_t S32; typedef uint64_t U64; #else typedef unsigned char BYTE; typedef unsigned short U16; typedef signed short S16; typedef unsigned int U32; typedef signed int S32; typedef unsigned long long U64; #endif #endif /* MEM_ACCESS_MODULE */ /******************************************************** * Constants *********************************************************/ static const U32 ZSTD_magicNumber = 0xFD2FB51E; /* 3rd version : seqNb header */ #define HASH_LOG (ZSTD_MEMORY_USAGE - 2) #define HASH_TABLESIZE (1 << HASH_LOG) #define HASH_MASK (HASH_TABLESIZE - 1) #define KNUTH 2654435761 #define BIT7 128 #define BIT6 64 #define BIT5 32 #define BIT4 16 #define KB *(1 <<10) #define MB *(1 <<20) #define GB *(1U<<30) #define BLOCKSIZE (128 KB) /* define, for static allocation */ #define WORKPLACESIZE (BLOCKSIZE*3) #define MINMATCH 4 #define MLbits 7 #define LLbits 6 #define Offbits 5 #define MaxML ((1<>3]; #else U32 hashTable[HASH_TABLESIZE]; #endif BYTE buffer[WORKPLACESIZE]; } cctxi_t; /************************************** * Error Management **************************************/ /* published entry point */ unsigned ZSTDv01_isError(size_t code) { return ERR_isError(code); } /************************************** * Tool functions **************************************/ #define ZSTD_VERSION_MAJOR 0 /* for breaking interface changes */ #define ZSTD_VERSION_MINOR 1 /* for new (non-breaking) interface capabilities */ #define ZSTD_VERSION_RELEASE 3 /* for tweaks, bug-fixes, or development */ #define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE) /************************************************************** * Decompression code **************************************************************/ size_t ZSTDv01_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr) { const BYTE* const in = (const BYTE* const)src; BYTE headerFlags; U32 cSize; if (srcSize < 3) return ERROR(srcSize_wrong); headerFlags = *in; cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16); bpPtr->blockType = (blockType_t)(headerFlags >> 6); bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0; if (bpPtr->blockType == bt_end) return 0; if (bpPtr->blockType == bt_rle) return 1; return cSize; } static size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize) { if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall); memcpy(dst, src, srcSize); return srcSize; } static size_t ZSTD_decompressLiterals(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) { BYTE* op = (BYTE*)dst; BYTE* const oend = op + maxDstSize; const BYTE* ip = (const BYTE*)src; size_t errorCode; size_t litSize; /* check : minimum 2, for litSize, +1, for content */ if (srcSize <= 3) return ERROR(corruption_detected); litSize = ip[1] + (ip[0]<<8); litSize += ((ip[-3] >> 3) & 7) << 16; // mmmmh.... op = oend - litSize; (void)ctx; if (litSize > maxDstSize) return ERROR(dstSize_tooSmall); errorCode = HUF_decompress(op, litSize, ip+2, srcSize-2); if (FSE_isError(errorCode)) return ERROR(GENERIC); return litSize; } size_t ZSTDv01_decodeLiteralsBlock(void* ctx, void* dst, size_t maxDstSize, const BYTE** litStart, size_t* litSize, const void* src, size_t srcSize) { const BYTE* const istart = (const BYTE* const)src; const BYTE* ip = istart; BYTE* const ostart = (BYTE* const)dst; BYTE* const oend = ostart + maxDstSize; blockProperties_t litbp; size_t litcSize = ZSTDv01_getcBlockSize(src, srcSize, &litbp); if (ZSTDv01_isError(litcSize)) return litcSize; if (litcSize > srcSize - ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); ip += ZSTD_blockHeaderSize; switch(litbp.blockType) { case bt_raw: *litStart = ip; ip += litcSize; *litSize = litcSize; break; case bt_rle: { size_t rleSize = litbp.origSize; if (rleSize>maxDstSize) return ERROR(dstSize_tooSmall); if (!srcSize) return ERROR(srcSize_wrong); memset(oend - rleSize, *ip, rleSize); *litStart = oend - rleSize; *litSize = rleSize; ip++; break; } case bt_compressed: { size_t decodedLitSize = ZSTD_decompressLiterals(ctx, dst, maxDstSize, ip, litcSize); if (ZSTDv01_isError(decodedLitSize)) return decodedLitSize; *litStart = oend - decodedLitSize; *litSize = decodedLitSize; ip += litcSize; break; } case bt_end: default: return ERROR(GENERIC); } return ip-istart; } size_t ZSTDv01_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr, FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb, const void* src, size_t srcSize) { const BYTE* const istart = (const BYTE* const)src; const BYTE* ip = istart; const BYTE* const iend = istart + srcSize; U32 LLtype, Offtype, MLtype; U32 LLlog, Offlog, MLlog; size_t dumpsLength; /* check */ if (srcSize < 5) return ERROR(srcSize_wrong); /* SeqHead */ *nbSeq = ZSTD_readLE16(ip); ip+=2; LLtype = *ip >> 6; Offtype = (*ip >> 4) & 3; MLtype = (*ip >> 2) & 3; if (*ip & 2) { dumpsLength = ip[2]; dumpsLength += ip[1] << 8; ip += 3; } else { dumpsLength = ip[1]; dumpsLength += (ip[0] & 1) << 8; ip += 2; } *dumpsPtr = ip; ip += dumpsLength; *dumpsLengthPtr = dumpsLength; /* check */ if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */ /* sequences */ { S16 norm[MaxML+1]; /* assumption : MaxML >= MaxLL and MaxOff */ size_t headerSize; /* Build DTables */ switch(LLtype) { case bt_rle : LLlog = 0; FSE_buildDTable_rle(DTableLL, *ip++); break; case bt_raw : LLlog = LLbits; FSE_buildDTable_raw(DTableLL, LLbits); break; default : { U32 max = MaxLL; headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip); if (FSE_isError(headerSize)) return ERROR(GENERIC); if (LLlog > LLFSELog) return ERROR(corruption_detected); ip += headerSize; FSE_buildDTable(DTableLL, norm, max, LLlog); } } switch(Offtype) { case bt_rle : Offlog = 0; if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */ FSE_buildDTable_rle(DTableOffb, *ip++); break; case bt_raw : Offlog = Offbits; FSE_buildDTable_raw(DTableOffb, Offbits); break; default : { U32 max = MaxOff; headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip); if (FSE_isError(headerSize)) return ERROR(GENERIC); if (Offlog > OffFSELog) return ERROR(corruption_detected); ip += headerSize; FSE_buildDTable(DTableOffb, norm, max, Offlog); } } switch(MLtype) { case bt_rle : MLlog = 0; if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */ FSE_buildDTable_rle(DTableML, *ip++); break; case bt_raw : MLlog = MLbits; FSE_buildDTable_raw(DTableML, MLbits); break; default : { U32 max = MaxML; headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip); if (FSE_isError(headerSize)) return ERROR(GENERIC); if (MLlog > MLFSELog) return ERROR(corruption_detected); ip += headerSize; FSE_buildDTable(DTableML, norm, max, MLlog); } } } return ip-istart; } typedef struct { size_t litLength; size_t offset; size_t matchLength; } seq_t; typedef struct { FSE_DStream_t DStream; FSE_DState_t stateLL; FSE_DState_t stateOffb; FSE_DState_t stateML; size_t prevOffset; const BYTE* dumps; const BYTE* dumpsEnd; } seqState_t; static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState) { size_t litLength; size_t prevOffset; size_t offset; size_t matchLength; const BYTE* dumps = seqState->dumps; const BYTE* const de = seqState->dumpsEnd; /* Literal length */ litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream)); prevOffset = litLength ? seq->offset : seqState->prevOffset; seqState->prevOffset = seq->offset; if (litLength == MaxLL) { U32 add = dumps 1 byte */ dumps += 3; } } } /* Offset */ { U32 offsetCode, nbBits; offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream)); if (ZSTD_32bits()) FSE_reloadDStream(&(seqState->DStream)); nbBits = offsetCode - 1; if (offsetCode==0) nbBits = 0; /* cmove */ offset = ((size_t)1 << (nbBits & ((sizeof(offset)*8)-1))) + FSE_readBits(&(seqState->DStream), nbBits); if (ZSTD_32bits()) FSE_reloadDStream(&(seqState->DStream)); if (offsetCode==0) offset = prevOffset; } /* MatchLength */ matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream)); if (matchLength == MaxML) { U32 add = dumps 1 byte */ dumps += 3; } } } matchLength += MINMATCH; /* save result */ seq->litLength = litLength; seq->offset = offset; seq->matchLength = matchLength; seqState->dumps = dumps; } static size_t ZSTD_execSequence(BYTE* op, seq_t sequence, const BYTE** litPtr, const BYTE* const litLimit, BYTE* const base, BYTE* const oend) { static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4}; /* added */ static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11}; /* substracted */ const BYTE* const ostart = op; const size_t litLength = sequence.litLength; BYTE* const endMatch = op + litLength + sequence.matchLength; /* risk : address space overflow (32-bits) */ const BYTE* const litEnd = *litPtr + litLength; /* check */ if (endMatch > oend) return ERROR(dstSize_tooSmall); /* overwrite beyond dst buffer */ if (litEnd > litLimit) return ERROR(corruption_detected); if (sequence.matchLength > (size_t)(*litPtr-op)) return ERROR(dstSize_tooSmall); /* overwrite literal segment */ /* copy Literals */ if (((size_t)(*litPtr - op) < 8) || ((size_t)(oend-litEnd) < 8) || (op+litLength > oend-8)) memmove(op, *litPtr, litLength); /* overwrite risk */ else ZSTD_wildcopy(op, *litPtr, litLength); op += litLength; *litPtr = litEnd; /* update for next sequence */ /* check : last match must be at a minimum distance of 8 from end of dest buffer */ if (oend-op < 8) return ERROR(dstSize_tooSmall); /* copy Match */ { const U32 overlapRisk = (((size_t)(litEnd - endMatch)) < 12); const BYTE* match = op - sequence.offset; /* possible underflow at op - offset ? */ size_t qutt = 12; U64 saved[2]; /* check */ if (match < base) return ERROR(corruption_detected); if (sequence.offset > (size_t)base) return ERROR(corruption_detected); /* save beginning of literal sequence, in case of write overlap */ if (overlapRisk) { if ((endMatch + qutt) > oend) qutt = oend-endMatch; memcpy(saved, endMatch, qutt); } if (sequence.offset < 8) { const int dec64 = dec64table[sequence.offset]; op[0] = match[0]; op[1] = match[1]; op[2] = match[2]; op[3] = match[3]; match += dec32table[sequence.offset]; ZSTD_copy4(op+4, match); match -= dec64; } else { ZSTD_copy8(op, match); } op += 8; match += 8; if (endMatch > oend-(16-MINMATCH)) { if (op < oend-8) { ZSTD_wildcopy(op, match, (oend-8) - op); match += (oend-8) - op; op = oend-8; } while (opLLTable; U32* DTableML = dctx->MLTable; U32* DTableOffb = dctx->OffTable; BYTE* const base = (BYTE*) (dctx->base); /* Build Decoding Tables */ errorCode = ZSTDv01_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength, DTableLL, DTableML, DTableOffb, ip, iend-ip); if (ZSTDv01_isError(errorCode)) return errorCode; ip += errorCode; /* Regen sequences */ { seq_t sequence; seqState_t seqState; memset(&sequence, 0, sizeof(sequence)); seqState.dumps = dumps; seqState.dumpsEnd = dumps + dumpsLength; seqState.prevOffset = 1; errorCode = FSE_initDStream(&(seqState.DStream), ip, iend-ip); if (FSE_isError(errorCode)) return ERROR(corruption_detected); FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL); FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb); FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML); for ( ; (FSE_reloadDStream(&(seqState.DStream)) <= FSE_DStream_completed) && (nbSeq>0) ; ) { size_t oneSeqSize; nbSeq--; ZSTD_decodeSequence(&sequence, &seqState); oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litEnd, base, oend); if (ZSTDv01_isError(oneSeqSize)) return oneSeqSize; op += oneSeqSize; } /* check if reached exact end */ if ( !FSE_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected); /* requested too much : data is corrupted */ if (nbSeq<0) return ERROR(corruption_detected); /* requested too many sequences : data is corrupted */ /* last literal segment */ { size_t lastLLSize = litEnd - litPtr; if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall); if (op != litPtr) memmove(op, litPtr, lastLLSize); op += lastLLSize; } } return op-ostart; } static size_t ZSTD_decompressBlock( void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) { /* blockType == blockCompressed, srcSize is trusted */ const BYTE* ip = (const BYTE*)src; const BYTE* litPtr = NULL; size_t litSize = 0; size_t errorCode; /* Decode literals sub-block */ errorCode = ZSTDv01_decodeLiteralsBlock(ctx, dst, maxDstSize, &litPtr, &litSize, src, srcSize); if (ZSTDv01_isError(errorCode)) return errorCode; ip += errorCode; srcSize -= errorCode; return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize, litPtr, litSize); } size_t ZSTDv01_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) { const BYTE* ip = (const BYTE*)src; const BYTE* iend = ip + srcSize; BYTE* const ostart = (BYTE* const)dst; BYTE* op = ostart; BYTE* const oend = ostart + maxDstSize; size_t remainingSize = srcSize; U32 magicNumber; size_t errorCode=0; blockProperties_t blockProperties; /* Frame Header */ if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); magicNumber = ZSTD_readBE32(src); if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown); ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize; /* Loop on each block */ while (1) { size_t blockSize = ZSTDv01_getcBlockSize(ip, iend-ip, &blockProperties); if (ZSTDv01_isError(blockSize)) return blockSize; ip += ZSTD_blockHeaderSize; remainingSize -= ZSTD_blockHeaderSize; if (blockSize > remainingSize) return ERROR(srcSize_wrong); switch(blockProperties.blockType) { case bt_compressed: errorCode = ZSTD_decompressBlock(ctx, op, oend-op, ip, blockSize); break; case bt_raw : errorCode = ZSTD_copyUncompressedBlock(op, oend-op, ip, blockSize); break; case bt_rle : return ERROR(GENERIC); /* not yet supported */ break; case bt_end : /* end of frame */ if (remainingSize) return ERROR(srcSize_wrong); break; default: return ERROR(GENERIC); } if (blockSize == 0) break; /* bt_end */ if (ZSTDv01_isError(errorCode)) return errorCode; op += errorCode; ip += blockSize; remainingSize -= blockSize; } return op-ostart; } size_t ZSTDv01_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize) { dctx_t ctx; ctx.base = dst; return ZSTDv01_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize); } size_t ZSTDv01_findFrameCompressedSize(const void* src, size_t srcSize) { const BYTE* ip = (const BYTE*)src; size_t remainingSize = srcSize; U32 magicNumber; blockProperties_t blockProperties; /* Frame Header */ if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); magicNumber = ZSTD_readBE32(src); if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown); ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize; /* Loop on each block */ while (1) { size_t blockSize = ZSTDv01_getcBlockSize(ip, remainingSize, &blockProperties); if (ZSTDv01_isError(blockSize)) return blockSize; ip += ZSTD_blockHeaderSize; remainingSize -= ZSTD_blockHeaderSize; if (blockSize > remainingSize) return ERROR(srcSize_wrong); if (blockSize == 0) break; /* bt_end */ ip += blockSize; remainingSize -= blockSize; } return ip - (const BYTE*)src; } /******************************* * Streaming Decompression API *******************************/ size_t ZSTDv01_resetDCtx(ZSTDv01_Dctx* dctx) { dctx->expected = ZSTD_frameHeaderSize; dctx->phase = 0; dctx->previousDstEnd = NULL; dctx->base = NULL; return 0; } ZSTDv01_Dctx* ZSTDv01_createDCtx(void) { ZSTDv01_Dctx* dctx = (ZSTDv01_Dctx*)malloc(sizeof(ZSTDv01_Dctx)); if (dctx==NULL) return NULL; ZSTDv01_resetDCtx(dctx); return dctx; } size_t ZSTDv01_freeDCtx(ZSTDv01_Dctx* dctx) { free(dctx); return 0; } size_t ZSTDv01_nextSrcSizeToDecompress(ZSTDv01_Dctx* dctx) { return ((dctx_t*)dctx)->expected; } size_t ZSTDv01_decompressContinue(ZSTDv01_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) { dctx_t* ctx = (dctx_t*)dctx; /* Sanity check */ if (srcSize != ctx->expected) return ERROR(srcSize_wrong); if (dst != ctx->previousDstEnd) /* not contiguous */ ctx->base = dst; /* Decompress : frame header */ if (ctx->phase == 0) { /* Check frame magic header */ U32 magicNumber = ZSTD_readBE32(src); if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown); ctx->phase = 1; ctx->expected = ZSTD_blockHeaderSize; return 0; } /* Decompress : block header */ if (ctx->phase == 1) { blockProperties_t bp; size_t blockSize = ZSTDv01_getcBlockSize(src, ZSTD_blockHeaderSize, &bp); if (ZSTDv01_isError(blockSize)) return blockSize; if (bp.blockType == bt_end) { ctx->expected = 0; ctx->phase = 0; } else { ctx->expected = blockSize; ctx->bType = bp.blockType; ctx->phase = 2; } return 0; } /* Decompress : block content */ { size_t rSize; switch(ctx->bType) { case bt_compressed: rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize); break; case bt_raw : rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize); break; case bt_rle : return ERROR(GENERIC); /* not yet handled */ break; case bt_end : /* should never happen (filtered at phase 1) */ rSize = 0; break; default: return ERROR(GENERIC); } ctx->phase = 1; ctx->expected = ZSTD_blockHeaderSize; ctx->previousDstEnd = (void*)( ((char*)dst) + rSize); return rSize; } } ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_v01.h ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #ifndef ZSTD_V01_H_28739879432 #define ZSTD_V01_H_28739879432 #if defined (__cplusplus) extern "C" { #endif /* ************************************* * Includes ***************************************/ #include /* size_t */ /* ************************************* * Simple one-step function ***************************************/ /** ZSTDv01_decompress() : decompress ZSTD frames compliant with v0.1.x format compressedSize : is the exact source size maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated. It must be equal or larger than originalSize, otherwise decompression will fail. return : the number of bytes decompressed into destination buffer (originalSize) or an errorCode if it fails (which can be tested using ZSTDv01_isError()) */ size_t ZSTDv01_decompress( void* dst, size_t maxOriginalSize, const void* src, size_t compressedSize); /** ZSTDv01_getFrameSrcSize() : get the source length of a ZSTD frame compliant with v0.1.x format compressedSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src' return : the number of bytes that would be read to decompress this frame or an errorCode if it fails (which can be tested using ZSTDv01_isError()) */ size_t ZSTDv01_findFrameCompressedSize(const void* src, size_t compressedSize); /** ZSTDv01_isError() : tells if the result of ZSTDv01_decompress() is an error */ unsigned ZSTDv01_isError(size_t code); /* ************************************* * Advanced functions ***************************************/ typedef struct ZSTDv01_Dctx_s ZSTDv01_Dctx; ZSTDv01_Dctx* ZSTDv01_createDCtx(void); size_t ZSTDv01_freeDCtx(ZSTDv01_Dctx* dctx); size_t ZSTDv01_decompressDCtx(void* ctx, void* dst, size_t maxOriginalSize, const void* src, size_t compressedSize); /* ************************************* * Streaming functions ***************************************/ size_t ZSTDv01_resetDCtx(ZSTDv01_Dctx* dctx); size_t ZSTDv01_nextSrcSizeToDecompress(ZSTDv01_Dctx* dctx); size_t ZSTDv01_decompressContinue(ZSTDv01_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize); /** Use above functions alternatively. ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue(). ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block. Result is the number of bytes regenerated within 'dst'. It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header. */ /* ************************************* * Prefix - version detection ***************************************/ #define ZSTDv01_magicNumber 0xFD2FB51E /* Big Endian version */ #define ZSTDv01_magicNumberLE 0x1EB52FFD /* Little Endian version */ #if defined (__cplusplus) } #endif #endif /* ZSTD_V01_H_28739879432 */ ================================================ FILE: rocketmq-knative/source/vendor/github.com/DataDog/zstd/zstd_v02.c ================================================ /* * Copyright (c) 2016-present, Yann Collet, Facebook, Inc. * All rights reserved. * * This source code is licensed under both the BSD-style license (found in the * LICENSE file in the root directory of this source tree) and the GPLv2 (found * in the COPYING file in the root directory of this source tree). * You may select, at your option, one of the above-listed licenses. */ #include /* size_t, ptrdiff_t */ #include "zstd_v02.h" #include "error_private.h" /****************************************** * Compiler-specific ******************************************/ #if defined(_MSC_VER) /* Visual Studio */ # include /* _byteswap_ulong */ # include /* _byteswap_* */ #endif /* ****************************************************************** mem.h low-level memory access routines Copyright (C) 2013-2015, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c ****************************************************************** */ #ifndef MEM_H_MODULE #define MEM_H_MODULE #if defined (__cplusplus) extern "C" { #endif /****************************************** * Includes ******************************************/ #include /* size_t, ptrdiff_t */ #include /* memcpy */ /****************************************** * Compiler-specific ******************************************/ #if defined(__GNUC__) # define MEM_STATIC static __attribute__((unused)) #elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) # define MEM_STATIC static inline #elif defined(_MSC_VER) # define MEM_STATIC static __inline #else # define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */ #endif /**************************************************************** * Basic Types *****************************************************************/ #if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) # include typedef uint8_t BYTE; typedef uint16_t U16; typedef int16_t S16; typedef uint32_t U32; typedef int32_t S32; typedef uint64_t U64; typedef int64_t S64; #else typedef unsigned char BYTE; typedef unsigned short U16; typedef signed short S16; typedef unsigned int U32; typedef signed int S32; typedef unsigned long long U64; typedef signed long long S64; #endif /**************************************************************** * Memory I/O *****************************************************************/ /* MEM_FORCE_MEMORY_ACCESS * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable. * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal. * The below switch allow to select different access method for improved performance. * Method 0 (default) : use `memcpy()`. Safe and portable. * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable). * This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`. * Method 2 : direct access. This method is portable but violate C standard. * It can generate buggy code on targets generating assembly depending on alignment. * But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details. * Prefer these methods in priority order (0 > 1 > 2) */ #ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */ # if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) ) # define MEM_FORCE_MEMORY_ACCESS 2 # elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \ (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) )) # define MEM_FORCE_MEMORY_ACCESS 1 # endif #endif MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; } MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; } MEM_STATIC unsigned MEM_isLittleEndian(void) { const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */ return one.c[0]; } #if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2) /* violates C standard on structure alignment. Only use if no other choice to achieve best performance on target platform */ MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; } MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; } MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; } MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; } #elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1) /* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */ /* currently only defined for gcc and icc */ typedef union { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign; MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; } MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; } MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; } #else /* default method, safe and standard. can sometimes prove slower */ MEM_STATIC U16 MEM_read16(const void* memPtr) { U16 val; memcpy(&val, memPtr, sizeof(val)); return val; } MEM_STATIC U32 MEM_read32(const void* memPtr) { U32 val; memcpy(&val, memPtr, sizeof(val)); return val; } MEM_STATIC U64 MEM_read64(const void* memPtr) { U64 val; memcpy(&val, memPtr, sizeof(val)); return val; } MEM_STATIC void MEM_write16(void* memPtr, U16 value) { memcpy(memPtr, &value, sizeof(value)); } #endif // MEM_FORCE_MEMORY_ACCESS MEM_STATIC U16 MEM_readLE16(const void* memPtr) { if (MEM_isLittleEndian()) return MEM_read16(memPtr); else { const BYTE* p = (const BYTE*)memPtr; return (U16)(p[0] + (p[1]<<8)); } } MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val) { if (MEM_isLittleEndian()) { MEM_write16(memPtr, val); } else { BYTE* p = (BYTE*)memPtr; p[0] = (BYTE)val; p[1] = (BYTE)(val>>8); } } MEM_STATIC U32 MEM_readLE32(const void* memPtr) { if (MEM_isLittleEndian()) return MEM_read32(memPtr); else { const BYTE* p = (const BYTE*)memPtr; return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24)); } } MEM_STATIC U64 MEM_readLE64(const void* memPtr) { if (MEM_isLittleEndian()) return MEM_read64(memPtr); else { const BYTE* p = (const BYTE*)memPtr; return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24) + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56)); } } MEM_STATIC size_t MEM_readLEST(const void* memPtr) { if (MEM_32bits()) return (size_t)MEM_readLE32(memPtr); else return (size_t)MEM_readLE64(memPtr); } #if defined (__cplusplus) } #endif #endif /* MEM_H_MODULE */ /* ****************************************************************** bitstream Part of NewGen Entropy library header file (to include) Copyright (C) 2013-2015, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - Source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c ****************************************************************** */ #ifndef BITSTREAM_H_MODULE #define BITSTREAM_H_MODULE #if defined (__cplusplus) extern "C" { #endif /* * This API consists of small unitary functions, which highly benefit from being inlined. * Since link-time-optimization is not available for all compilers, * these functions are defined into a .h to be included. */ /********************************************** * bitStream decompression API (read backward) **********************************************/ typedef struct { size_t bitContainer; unsigned bitsConsumed; const char* ptr; const char* start; } BIT_DStream_t; typedef enum { BIT_DStream_unfinished = 0, BIT_DStream_endOfBuffer = 1, BIT_DStream_completed = 2, BIT_DStream_overflow = 3 } BIT_DStream_status; /* result of BIT_reloadDStream() */ /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize); MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits); MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD); MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD); /****************************************** * unsafe API ******************************************/ MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits); /* faster, but works only if nbBits >= 1 */ /**************************************************************** * Helper functions ****************************************************************/ MEM_STATIC unsigned BIT_highbit32 (U32 val) { # if defined(_MSC_VER) /* Visual */ unsigned long r=0; _BitScanReverse ( &r, val ); return (unsigned) r; # elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */ return 31 - __builtin_clz (val); # else /* Software version */ static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; U32 v = val; unsigned r; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; return r; # endif } /********************************************************** * bitStream decoding **********************************************************/ /*!BIT_initDStream * Initialize a BIT_DStream_t. * @bitD : a pointer to an already allocated BIT_DStream_t structure * @srcBuffer must point at the beginning of a bitStream * @srcSize must be the exact size of the bitStream * @result : size of stream (== srcSize) or an errorCode if a problem is detected */ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize) { if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } if (srcSize >= sizeof(size_t)) /* normal case */ { U32 contain32; bitD->start = (const char*)srcBuffer; bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(size_t); bitD->bitContainer = MEM_readLEST(bitD->ptr); contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */ bitD->bitsConsumed = 8 - BIT_highbit32(contain32); } else { U32 contain32; bitD->start = (const char*)srcBuffer; bitD->ptr = bitD->start; bitD->bitContainer = *(const BYTE*)(bitD->start); switch(srcSize) { case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16); case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24); case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32); case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) << 8; default:; } contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; if (contain32 == 0) return ERROR(GENERIC); /* endMark not present */ bitD->bitsConsumed = 8 - BIT_highbit32(contain32); bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8; } return srcSize; } MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits) { const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask); } /*! BIT_lookBitsFast : * unsafe version; only works only if nbBits >= 1 */ MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits) { const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask); } MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits) { bitD->bitsConsumed += nbBits; } MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits) { size_t value = BIT_lookBits(bitD, nbBits); BIT_skipBits(bitD, nbBits); return value; } /*!BIT_readBitsFast : * unsafe version; only works only if nbBits >= 1 */ MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits) { size_t value = BIT_lookBitsFast(bitD, nbBits); BIT_skipBits(bitD, nbBits); return value; } MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD) { if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* should never happen */ return BIT_DStream_overflow; if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) { bitD->ptr -= bitD->bitsConsumed >> 3; bitD->bitsConsumed &= 7; bitD->bitContainer = MEM_readLEST(bitD->ptr); return BIT_DStream_unfinished; } if (bitD->ptr == bitD->start) { if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; return BIT_DStream_completed; } { U32 nbBytes = bitD->bitsConsumed >> 3; BIT_DStream_status result = BIT_DStream_unfinished; if (bitD->ptr - nbBytes < bitD->start) { nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ result = BIT_DStream_endOfBuffer; } bitD->ptr -= nbBytes; bitD->bitsConsumed -= nbBytes*8; bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD) */ return result; } } /*! BIT_endOfDStream * @return Tells if DStream has reached its exact end */ MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream) { return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8)); } #if defined (__cplusplus) } #endif #endif /* BITSTREAM_H_MODULE */ /* ****************************************************************** Error codes and messages Copyright (C) 2013-2015, Yann Collet BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - Source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c ****************************************************************** */ #ifndef ERROR_H_MODULE #define ERROR_H_MODULE #if defined (__cplusplus) extern "C" { #endif /****************************************** * Compiler-specific ******************************************/ #if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) # define ERR_STATIC static inline #elif defined(_MSC_VER) # define ERR_STATIC static __inline #elif defined(__GNUC__) # define ERR_STATIC static __attribute__((unused)) #else # define ERR_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */ #endif /****************************************** * Error Management ******************************************/ #define PREFIX(name) ZSTD_error_##name #define ERROR(name) (size_t)-PREFIX(name) #define ERROR_LIST(ITEM) \ ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \ ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \ ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \ ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \ ITEM(PREFIX(maxCode)) #define ERROR_GENERATE_ENUM(ENUM) ENUM, typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes; /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */ #define ERROR_CONVERTTOSTRING(STRING) #STRING, #define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR) static const char* ERR_strings[] = { ERROR_LIST(ERROR_GENERATE_STRING) }; ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); } ERR_STATIC const char* ERR_getErrorName(size_t code) { static const char* codeError = "Unspecified error code"; if (ERR_isError(code)) return ERR_strings[-(int)(code)]; return codeError; } #if defined (__cplusplus) } #endif #endif /* ERROR_H_MODULE */ /* Constructor and Destructor of type FSE_CTable Note that its size depends on 'tableLog' and 'maxSymbolValue' */ typedef unsigned FSE_CTable; /* don't allocate that. It's just a way to be more restrictive than void* */ typedef unsigned FSE_DTable; /* don't allocate that. It's just a way to be more restrictive than void* */ /* ****************************************************************** FSE : Finite State Entropy coder header file for static linking (only) Copyright (C) 2013-2015, Yann Collet BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - Source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c ****************************************************************** */ #if defined (__cplusplus) extern "C" { #endif /****************************************** * Static allocation ******************************************/ /* FSE buffer bounds */ #define FSE_NCOUNTBOUND 512 #define FSE_BLOCKBOUND(size) (size + (size>>7)) #define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size)) /* Macro version, useful for static allocation */ /* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */ #define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2)) #define FSE_DTABLE_SIZE_U32(maxTableLog) (1 + (1<= 1 (otherwise, result will be corrupted) */ /****************************************** * Implementation of inline functions ******************************************/ /* decompression */ typedef struct { U16 tableLog; U16 fastMode; } FSE_DTableHeader; /* sizeof U32 */ typedef struct { unsigned short newState; unsigned char symbol; unsigned char nbBits; } FSE_decode_t; /* size == U32 */ MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt) { FSE_DTableHeader DTableH; memcpy(&DTableH, dt, sizeof(DTableH)); DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog); BIT_reloadDStream(bitD); DStatePtr->table = dt + 1; } MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) { const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; const U32 nbBits = DInfo.nbBits; BYTE symbol = DInfo.symbol; size_t lowBits = BIT_readBits(bitD, nbBits); DStatePtr->state = DInfo.newState + lowBits; return symbol; } MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) { const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; const U32 nbBits = DInfo.nbBits; BYTE symbol = DInfo.symbol; size_t lowBits = BIT_readBitsFast(bitD, nbBits); DStatePtr->state = DInfo.newState + lowBits; return symbol; } MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr) { return DStatePtr->state == 0; } #if defined (__cplusplus) } #endif /* ****************************************************************** Huff0 : Huffman coder, part of New Generation Entropy library header file for static linking (only) Copyright (C) 2013-2015, Yann Collet BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - Source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c ****************************************************************** */ #if defined (__cplusplus) extern "C" { #endif /****************************************** * Static allocation macros ******************************************/ /* Huff0 buffer bounds */ #define HUF_CTABLEBOUND 129 #define HUF_BLOCKBOUND(size) (size + (size>>8) + 8) /* only true if incompressible pre-filtered with fast heuristic */ #define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size)) /* Macro version, useful for static allocation */ /* static allocation of Huff0's DTable */ #define HUF_DTABLE_SIZE(maxTableLog) (1 + (1< /* size_t */ /* ************************************* * Version ***************************************/ #define ZSTD_VERSION_MAJOR 0 /* for breaking interface changes */ #define ZSTD_VERSION_MINOR 2 /* for new (non-breaking) interface capabilities */ #define ZSTD_VERSION_RELEASE 2 /* for tweaks, bug-fixes, or development */ #define ZSTD_VERSION_NUMBER (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE) /* ************************************* * Advanced functions ***************************************/ typedef struct ZSTD_CCtx_s ZSTD_CCtx; /* incomplete type */ #if defined (__cplusplus) } #endif /* zstd - standard compression library Header File for static linking only Copyright (C) 2014-2015, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - zstd source repository : https://github.com/Cyan4973/zstd - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c */ /* The objects defined into this file should be considered experimental. * They are not labelled stable, as their prototype may change in the future. * You can use them for tests, provide feedback, or if you can endure risk of future changes. */ #if defined (__cplusplus) extern "C" { #endif /* ************************************* * Streaming functions ***************************************/ typedef struct ZSTD_DCtx_s ZSTD_DCtx; /* Use above functions alternatively. ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue(). ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block. Result is the number of bytes regenerated within 'dst'. It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header. */ /* ************************************* * Prefix - version detection ***************************************/ #define ZSTD_magicNumber 0xFD2FB522 /* v0.2 (current)*/ #if defined (__cplusplus) } #endif /* ****************************************************************** FSE : Finite State Entropy coder Copyright (C) 2013-2015, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c ****************************************************************** */ #ifndef FSE_COMMONDEFS_ONLY /**************************************************************** * Tuning parameters ****************************************************************/ /* MEMORY_USAGE : * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.) * Increasing memory usage improves compression ratio * Reduced memory usage can improve speed, due to cache effect * Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */ #define FSE_MAX_MEMORY_USAGE 14 #define FSE_DEFAULT_MEMORY_USAGE 13 /* FSE_MAX_SYMBOL_VALUE : * Maximum symbol value authorized. * Required for proper stack allocation */ #define FSE_MAX_SYMBOL_VALUE 255 /**************************************************************** * template functions type & suffix ****************************************************************/ #define FSE_FUNCTION_TYPE BYTE #define FSE_FUNCTION_EXTENSION /**************************************************************** * Byte symbol type ****************************************************************/ #endif /* !FSE_COMMONDEFS_ONLY */ /**************************************************************** * Compiler specifics ****************************************************************/ #ifdef _MSC_VER /* Visual Studio */ # define FORCE_INLINE static __forceinline # include /* For Visual 2005 */ # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ # pragma warning(disable : 4214) /* disable: C4214: non-int bitfields */ #else # if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 */ # ifdef __GNUC__ # define FORCE_INLINE static inline __attribute__((always_inline)) # else # define FORCE_INLINE static inline # endif # else # define FORCE_INLINE static # endif /* __STDC_VERSION__ */ #endif /**************************************************************** * Includes ****************************************************************/ #include /* malloc, free, qsort */ #include /* memcpy, memset */ #include /* printf (debug) */ /**************************************************************** * Constants *****************************************************************/ #define FSE_MAX_TABLELOG (FSE_MAX_MEMORY_USAGE-2) #define FSE_MAX_TABLESIZE (1U< FSE_TABLELOG_ABSOLUTE_MAX #error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported" #endif /**************************************************************** * Error Management ****************************************************************/ #define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ /**************************************************************** * Complex types ****************************************************************/ typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)]; /**************************************************************** * Templates ****************************************************************/ /* designed to be included for type-specific functions (template emulation in C) Objective is to write these functions only once, for improved maintenance */ /* safety checks */ #ifndef FSE_FUNCTION_EXTENSION # error "FSE_FUNCTION_EXTENSION must be defined" #endif #ifndef FSE_FUNCTION_TYPE # error "FSE_FUNCTION_TYPE must be defined" #endif /* Function names */ #define FSE_CAT(X,Y) X##Y #define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y) #define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y) /* Function templates */ #define FSE_DECODE_TYPE FSE_decode_t static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; } static size_t FSE_buildDTable (FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) { void* ptr = dt+1; FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)ptr; FSE_DTableHeader DTableH; const U32 tableSize = 1 << tableLog; const U32 tableMask = tableSize-1; const U32 step = FSE_tableStep(tableSize); U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1]; U32 position = 0; U32 highThreshold = tableSize-1; const S16 largeLimit= (S16)(1 << (tableLog-1)); U32 noLarge = 1; U32 s; /* Sanity Checks */ if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge); if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge); /* Init, lay down lowprob symbols */ DTableH.tableLog = (U16)tableLog; for (s=0; s<=maxSymbolValue; s++) { if (normalizedCounter[s]==-1) { tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s; symbolNext[s] = 1; } else { if (normalizedCounter[s] >= largeLimit) noLarge=0; symbolNext[s] = normalizedCounter[s]; } } /* Spread symbols */ for (s=0; s<=maxSymbolValue; s++) { int i; for (i=0; i highThreshold) position = (position + step) & tableMask; /* lowprob area */ } } if (position!=0) return ERROR(GENERIC); /* position must reach all cells once, otherwise normalizedCounter is incorrect */ /* Build Decoding table */ { U32 i; for (i=0; i FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge); bitStream >>= 4; bitCount = 4; *tableLogPtr = nbBits; remaining = (1<1) && (charnum<=*maxSVPtr)) { if (previous0) { unsigned n0 = charnum; while ((bitStream & 0xFFFF) == 0xFFFF) { n0+=24; if (ip < iend-5) { ip+=2; bitStream = MEM_readLE32(ip) >> bitCount; } else { bitStream >>= 16; bitCount+=16; } } while ((bitStream & 3) == 3) { n0+=3; bitStream>>=2; bitCount+=2; } n0 += bitStream & 3; bitCount += 2; if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall); while (charnum < n0) normalizedCounter[charnum++] = 0; if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { ip += bitCount>>3; bitCount &= 7; bitStream = MEM_readLE32(ip) >> bitCount; } else bitStream >>= 2; } { const short max = (short)((2*threshold-1)-remaining); short count; if ((bitStream & (threshold-1)) < (U32)max) { count = (short)(bitStream & (threshold-1)); bitCount += nbBits-1; } else { count = (short)(bitStream & (2*threshold-1)); if (count >= threshold) count -= max; bitCount += nbBits; } count--; /* extra accuracy */ remaining -= FSE_abs(count); normalizedCounter[charnum++] = count; previous0 = !count; while (remaining < threshold) { nbBits--; threshold >>= 1; } { if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { ip += bitCount>>3; bitCount &= 7; } else { bitCount -= (int)(8 * (iend - 4 - ip)); ip = iend - 4; } bitStream = MEM_readLE32(ip) >> (bitCount & 31); } } } if (remaining != 1) return ERROR(GENERIC); *maxSVPtr = charnum-1; ip += (bitCount+7)>>3; if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong); return ip-istart; } /********************************************************* * Decompression (Byte symbols) *********************************************************/ static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue) { void* ptr = dt; FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1; /* because dt is unsigned */ DTableH->tableLog = 0; DTableH->fastMode = 0; cell->newState = 0; cell->symbol = symbolValue; cell->nbBits = 0; return 0; } static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits) { void* ptr = dt; FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1; /* because dt is unsigned */ const unsigned tableSize = 1 << nbBits; const unsigned tableMask = tableSize - 1; const unsigned maxSymbolValue = tableMask; unsigned s; /* Sanity checks */ if (nbBits < 1) return ERROR(GENERIC); /* min size */ /* Build Decoding Table */ DTableH->tableLog = (U16)nbBits; DTableH->fastMode = 1; for (s=0; s<=maxSymbolValue; s++) { dinfo[s].newState = 0; dinfo[s].symbol = (BYTE)s; dinfo[s].nbBits = (BYTE)nbBits; } return 0; } FORCE_INLINE size_t FSE_decompress_usingDTable_generic( void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt, const unsigned fast) { BYTE* const ostart = (BYTE*) dst; BYTE* op = ostart; BYTE* const omax = op + maxDstSize; BYTE* const olimit = omax-3; BIT_DStream_t bitD; FSE_DState_t state1; FSE_DState_t state2; size_t errorCode; /* Init */ errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize); /* replaced last arg by maxCompressed Size */ if (FSE_isError(errorCode)) return errorCode; FSE_initDState(&state1, &bitD, dt); FSE_initDState(&state2, &bitD, dt); #define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD) /* 4 symbols per loop */ for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) && (op sizeof(bitD.bitContainer)*8) /* This test must be static */ BIT_reloadDStream(&bitD); op[1] = FSE_GETSYMBOL(&state2); if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */ { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } } op[2] = FSE_GETSYMBOL(&state1); if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8) /* This test must be static */ BIT_reloadDStream(&bitD); op[3] = FSE_GETSYMBOL(&state2); } /* tail */ /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */ while (1) { if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) ) break; *op++ = FSE_GETSYMBOL(&state1); if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) ) break; *op++ = FSE_GETSYMBOL(&state2); } /* end ? */ if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2)) return op-ostart; if (op==omax) return ERROR(dstSize_tooSmall); /* dst buffer is full, but cSrc unfinished */ return ERROR(corruption_detected); } static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt) { FSE_DTableHeader DTableH; memcpy(&DTableH, dt, sizeof(DTableH)); /* select fast mode (static) */ if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); } static size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize) { const BYTE* const istart = (const BYTE*)cSrc; const BYTE* ip = istart; short counting[FSE_MAX_SYMBOL_VALUE+1]; DTable_max_t dt; /* Static analyzer seems unable to understand this table will be properly initialized later */ unsigned tableLog; unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE; size_t errorCode; if (cSrcSize<2) return ERROR(srcSize_wrong); /* too small input size */ /* normal FSE decoding mode */ errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); if (FSE_isError(errorCode)) return errorCode; if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); /* too small input size */ ip += errorCode; cSrcSize -= errorCode; errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog); if (FSE_isError(errorCode)) return errorCode; /* always return, even if it is an error code */ return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt); } #endif /* FSE_COMMONDEFS_ONLY */ /* ****************************************************************** Huff0 : Huffman coder, part of New Generation Entropy library Copyright (C) 2013-2015, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. You can contact the author at : - FSE+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy - Public forum : https://groups.google.com/forum/#!forum/lz4c ****************************************************************** */ /**************************************************************** * Compiler specifics ****************************************************************/ #if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) /* inline is defined */ #elif defined(_MSC_VER) # define inline __inline #else # define inline /* disable inline */ #endif #ifdef _MSC_VER /* Visual Studio */ # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ #endif /**************************************************************** * Includes ****************************************************************/ #include /* malloc, free, qsort */ #include /* memcpy, memset */ #include /* printf (debug) */ /**************************************************************** * Error Management ****************************************************************/ #define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ /****************************************** * Helper functions ******************************************/ static unsigned HUF_isError(size_t code) { return ERR_isError(code); } #define HUF_ABSOLUTEMAX_TABLELOG 16 /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */ #define HUF_MAX_TABLELOG 12 /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */ #define HUF_DEFAULT_TABLELOG HUF_MAX_TABLELOG /* tableLog by default, when not specified */ #define HUF_MAX_SYMBOL_VALUE 255 #if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG) # error "HUF_MAX_TABLELOG is too large !" #endif /********************************************************* * Huff0 : Huffman block decompression *********************************************************/ typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2; /* single-symbol decoding */ typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4; /* double-symbols decoding */ typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t; /*! HUF_readStats Read compact Huffman tree, saved by HUF_writeCTable @huffWeight : destination buffer @return : size read from `src` */ static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr, const void* src, size_t srcSize) { U32 weightTotal; U32 tableLog; const BYTE* ip = (const BYTE*) src; size_t iSize; size_t oSize; U32 n; if (!srcSize) return ERROR(srcSize_wrong); iSize = ip[0]; //memset(huffWeight, 0, hwSize); /* is not necessary, even though some analyzer complain ... */ if (iSize >= 128) /* special header */ { if (iSize >= (242)) /* RLE */ { static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 }; oSize = l[iSize-242]; memset(huffWeight, 1, hwSize); iSize = 0; } else /* Incompressible */ { oSize = iSize - 127; iSize = ((oSize+1)/2); if (iSize+1 > srcSize) return ERROR(srcSize_wrong); if (oSize >= hwSize) return ERROR(corruption_detected); ip += 1; for (n=0; n> 4; huffWeight[n+1] = ip[n/2] & 15; } } } else /* header compressed with FSE (normal case) */ { if (iSize+1 > srcSize) return ERROR(srcSize_wrong); oSize = FSE_decompress(huffWeight, hwSize-1, ip+1, iSize); /* max (hwSize-1) values decoded, as last one is implied */ if (FSE_isError(oSize)) return oSize; } /* collect weight stats */ memset(rankStats, 0, (HUF_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32)); weightTotal = 0; for (n=0; n= HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected); rankStats[huffWeight[n]]++; weightTotal += (1 << huffWeight[n]) >> 1; } if (weightTotal == 0) return ERROR(corruption_detected); /* get last non-null symbol weight (implied, total must be 2^n) */ tableLog = BIT_highbit32(weightTotal) + 1; if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected); { U32 total = 1 << tableLog; U32 rest = total - weightTotal; U32 verif = 1 << BIT_highbit32(rest); U32 lastWeight = BIT_highbit32(rest) + 1; if (verif != rest) return ERROR(corruption_detected); /* last value must be a clean power of 2 */ huffWeight[oSize] = (BYTE)lastWeight; rankStats[lastWeight]++; } /* check tree construction validity */ if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected); /* by construction : at least 2 elts of rank 1, must be even */ /* results */ *nbSymbolsPtr = (U32)(oSize+1); *tableLogPtr = tableLog; return iSize+1; } /**************************/ /* single-symbol decoding */ /**************************/ static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize) { BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1]; U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; /* large enough for values from 0 to 16 */ U32 tableLog = 0; const BYTE* ip = (const BYTE*) src; size_t iSize = ip[0]; U32 nbSymbols = 0; U32 n; U32 nextRankStart; void* ptr = DTable+1; HUF_DEltX2* const dt = (HUF_DEltX2*)ptr; HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16)); /* if compilation fails here, assertion is false */ //memset(huffWeight, 0, sizeof(huffWeight)); /* is not necessary, even though some analyzer complain ... */ iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize); if (HUF_isError(iSize)) return iSize; /* check result */ if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge); /* DTable is too small */ DTable[0] = (U16)tableLog; /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */ /* Prepare ranks */ nextRankStart = 0; for (n=1; n<=tableLog; n++) { U32 current = nextRankStart; nextRankStart += (rankVal[n] << (n-1)); rankVal[n] = current; } /* fill DTable */ for (n=0; n> 1; U32 i; HUF_DEltX2 D; D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w); for (i = rankVal[w]; i < rankVal[w] + length; i++) dt[i] = D; rankVal[w] += length; } return iSize; } static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog) { const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ const BYTE c = dt[val].byte; BIT_skipBits(Dstream, dt[val].nbBits); return c; } #define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \ *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog) #define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \ if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \ HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) #define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \ if (MEM_64bits()) \ HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog) { BYTE* const pStart = p; /* up to 4 symbols at a time */ while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4)) { HUF_DECODE_SYMBOLX2_2(p, bitDPtr); HUF_DECODE_SYMBOLX2_1(p, bitDPtr); HUF_DECODE_SYMBOLX2_2(p, bitDPtr); HUF_DECODE_SYMBOLX2_0(p, bitDPtr); } /* closer to the end */ while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd)) HUF_DECODE_SYMBOLX2_0(p, bitDPtr); /* no more data to retrieve from bitstream, hence no need to reload */ while (p < pEnd) HUF_DECODE_SYMBOLX2_0(p, bitDPtr); return pEnd-pStart; } static size_t HUF_decompress4X2_usingDTable( void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, const U16* DTable) { if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */ { const BYTE* const istart = (const BYTE*) cSrc; BYTE* const ostart = (BYTE*) dst; BYTE* const oend = ostart + dstSize; const void* ptr = DTable; const HUF_DEltX2* const dt = ((const HUF_DEltX2*)ptr) +1; const U32 dtLog = DTable[0]; size_t errorCode; /* Init */ BIT_DStream_t bitD1; BIT_DStream_t bitD2; BIT_DStream_t bitD3; BIT_DStream_t bitD4; const size_t length1 = MEM_readLE16(istart); const size_t length2 = MEM_readLE16(istart+2); const size_t length3 = MEM_readLE16(istart+4); size_t length4; const BYTE* const istart1 = istart + 6; /* jumpTable */ const BYTE* const istart2 = istart1 + length1; const BYTE* const istart3 = istart2 + length2; const BYTE* const istart4 = istart3 + length3; const size_t segmentSize = (dstSize+3) / 4; BYTE* const opStart2 = ostart + segmentSize; BYTE* const opStart3 = opStart2 + segmentSize; BYTE* const opStart4 = opStart3 + segmentSize; BYTE* op1 = ostart; BYTE* op2 = opStart2; BYTE* op3 = opStart3; BYTE* op4 = opStart4; U32 endSignal; length4 = cSrcSize - (length1 + length2 + length3 + 6); if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */ errorCode = BIT_initDStream(&bitD1, istart1, length1); if (HUF_isError(errorCode)) return errorCode; errorCode = BIT_initDStream(&bitD2, istart2, length2); if (HUF_isError(errorCode)) return errorCode; errorCode = BIT_initDStream(&bitD3, istart3, length3); if (HUF_isError(errorCode)) return errorCode; errorCode = BIT_initDStream(&bitD4, istart4, length4); if (HUF_isError(errorCode)) return errorCode; /* 16-32 symbols per loop (4-8 symbols per stream) */ endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; ) { HUF_DECODE_SYMBOLX2_2(op1, &bitD1); HUF_DECODE_SYMBOLX2_2(op2, &bitD2); HUF_DECODE_SYMBOLX2_2(op3, &bitD3); HUF_DECODE_SYMBOLX2_2(op4, &bitD4); HUF_DECODE_SYMBOLX2_1(op1, &bitD1); HUF_DECODE_SYMBOLX2_1(op2, &bitD2); HUF_DECODE_SYMBOLX2_1(op3, &bitD3); HUF_DECODE_SYMBOLX2_1(op4, &bitD4); HUF_DECODE_SYMBOLX2_2(op1, &bitD1); HUF_DECODE_SYMBOLX2_2(op2, &bitD2); HUF_DECODE_SYMBOLX2_2(op3, &bitD3); HUF_DECODE_SYMBOLX2_2(op4, &bitD4); HUF_DECODE_SYMBOLX2_0(op1, &bitD1); HUF_DECODE_SYMBOLX2_0(op2, &bitD2); HUF_DECODE_SYMBOLX2_0(op3, &bitD3); HUF_DECODE_SYMBOLX2_0(op4, &bitD4); endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); } /* check corruption */ if (op1 > opStart2) return ERROR(corruption_detected); if (op2 > opStart3) return ERROR(corruption_detected); if (op3 > opStart4) return ERROR(corruption_detected); /* note : op4 supposed already verified within main loop */ /* finish bitStreams one by one */ HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog); HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog); HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog); HUF_decodeStreamX2(op4, &bitD4, oend, dt, dtLog); /* check */ endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); if (!endSignal) return ERROR(corruption_detected); /* decoded size */ return dstSize; } } static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG); const BYTE* ip = (const BYTE*) cSrc; size_t errorCode; errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize); if (HUF_isError(errorCode)) return errorCode; if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); ip += errorCode; cSrcSize -= errorCode; return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable); } /***************************/ /* double-symbols decoding */ /***************************/ static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed, const U32* rankValOrigin, const int minWeight, const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, U32 nbBitsBaseline, U16 baseSeq) { HUF_DEltX4 DElt; U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; U32 s; /* get pre-calculated rankVal */ memcpy(rankVal, rankValOrigin, sizeof(rankVal)); /* fill skipped values */ if (minWeight>1) { U32 i, skipSize = rankVal[minWeight]; MEM_writeLE16(&(DElt.sequence), baseSeq); DElt.nbBits = (BYTE)(consumed); DElt.length = 1; for (i = 0; i < skipSize; i++) DTable[i] = DElt; } /* fill DTable */ for (s=0; s= 1 */ rankVal[weight] += length; } } typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1]; static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog, const sortedSymbol_t* sortedList, const U32 sortedListSize, const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight, const U32 nbBitsBaseline) { U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; const int scaleLog = nbBitsBaseline - targetLog; /* note : targetLog >= srcLog, hence scaleLog <= 1 */ const U32 minBits = nbBitsBaseline - maxWeight; U32 s; memcpy(rankVal, rankValOrigin, sizeof(rankVal)); /* fill DTable */ for (s=0; s= minBits) /* enough room for a second symbol */ { U32 sortedRank; int minWeight = nbBits + scaleLog; if (minWeight < 1) minWeight = 1; sortedRank = rankStart[minWeight]; HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits, rankValOrigin[nbBits], minWeight, sortedList+sortedRank, sortedListSize-sortedRank, nbBitsBaseline, symbol); } else { U32 i; const U32 end = start + length; HUF_DEltX4 DElt; MEM_writeLE16(&(DElt.sequence), symbol); DElt.nbBits = (BYTE)(nbBits); DElt.length = 1; for (i = start; i < end; i++) DTable[i] = DElt; } rankVal[weight] += length; } } static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize) { BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1]; sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1]; U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 }; U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 }; U32* const rankStart = rankStart0+1; rankVal_t rankVal; U32 tableLog, maxW, sizeOfSort, nbSymbols; const U32 memLog = DTable[0]; const BYTE* ip = (const BYTE*) src; size_t iSize = ip[0]; void* ptr = DTable; HUF_DEltX4* const dt = ((HUF_DEltX4*)ptr) + 1; HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32)); /* if compilation fails here, assertion is false */ if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge); //memset(weightList, 0, sizeof(weightList)); /* is not necessary, even though some analyzer complain ... */ iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize); if (HUF_isError(iSize)) return iSize; /* check result */ if (tableLog > memLog) return ERROR(tableLog_tooLarge); /* DTable can't fit code depth */ /* find maxWeight */ for (maxW = tableLog; rankStats[maxW]==0; maxW--) {if (!maxW) return ERROR(GENERIC); } /* necessarily finds a solution before maxW==0 */ /* Get start index of each weight */ { U32 w, nextRankStart = 0; for (w=1; w<=maxW; w++) { U32 current = nextRankStart; nextRankStart += rankStats[w]; rankStart[w] = current; } rankStart[0] = nextRankStart; /* put all 0w symbols at the end of sorted list*/ sizeOfSort = nextRankStart; } /* sort symbols by weight */ { U32 s; for (s=0; s> consumed; } } } HUF_fillDTableX4(dt, memLog, sortedSymbol, sizeOfSort, rankStart0, rankVal, maxW, tableLog+1); return iSize; } static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog) { const size_t val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */ memcpy(op, dt+val, 2); BIT_skipBits(DStream, dt[val].nbBits); return dt[val].length; } static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog) { const size_t val = BIT_lookBitsFast(DStream, dtLog); /* note : dtLog >= 1 */ memcpy(op, dt+val, 1); if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits); else { if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) { BIT_skipBits(DStream, dt[val].nbBits); if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8)) DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8); /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */ } } return 1; } #define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \ ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) #define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \ if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \ ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) #define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \ if (MEM_64bits()) \ ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog) { BYTE* const pStart = p; /* up to 8 symbols at a time */ while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7)) { HUF_DECODE_SYMBOLX4_2(p, bitDPtr); HUF_DECODE_SYMBOLX4_1(p, bitDPtr); HUF_DECODE_SYMBOLX4_2(p, bitDPtr); HUF_DECODE_SYMBOLX4_0(p, bitDPtr); } /* closer to the end */ while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2)) HUF_DECODE_SYMBOLX4_0(p, bitDPtr); while (p <= pEnd-2) HUF_DECODE_SYMBOLX4_0(p, bitDPtr); /* no need to reload : reached the end of DStream */ if (p < pEnd) p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog); return p-pStart; } static size_t HUF_decompress4X4_usingDTable( void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, const U32* DTable) { if (cSrcSize < 10) return ERROR(corruption_detected); /* strict minimum : jump table + 1 byte per stream */ { const BYTE* const istart = (const BYTE*) cSrc; BYTE* const ostart = (BYTE*) dst; BYTE* const oend = ostart + dstSize; const void* ptr = DTable; const HUF_DEltX4* const dt = ((const HUF_DEltX4*)ptr) +1; const U32 dtLog = DTable[0]; size_t errorCode; /* Init */ BIT_DStream_t bitD1; BIT_DStream_t bitD2; BIT_DStream_t bitD3; BIT_DStream_t bitD4; const size_t length1 = MEM_readLE16(istart); const size_t length2 = MEM_readLE16(istart+2); const size_t length3 = MEM_readLE16(istart+4); size_t length4; const BYTE* const istart1 = istart + 6; /* jumpTable */ const BYTE* const istart2 = istart1 + length1; const BYTE* const istart3 = istart2 + length2; const BYTE* const istart4 = istart3 + length3; const size_t segmentSize = (dstSize+3) / 4; BYTE* const opStart2 = ostart + segmentSize; BYTE* const opStart3 = opStart2 + segmentSize; BYTE* const opStart4 = opStart3 + segmentSize; BYTE* op1 = ostart; BYTE* op2 = opStart2; BYTE* op3 = opStart3; BYTE* op4 = opStart4; U32 endSignal; length4 = cSrcSize - (length1 + length2 + length3 + 6); if (length4 > cSrcSize) return ERROR(corruption_detected); /* overflow */ errorCode = BIT_initDStream(&bitD1, istart1, length1); if (HUF_isError(errorCode)) return errorCode; errorCode = BIT_initDStream(&bitD2, istart2, length2); if (HUF_isError(errorCode)) return errorCode; errorCode = BIT_initDStream(&bitD3, istart3, length3); if (HUF_isError(errorCode)) return errorCode; errorCode = BIT_initDStream(&bitD4, istart4, length4); if (HUF_isError(errorCode)) return errorCode; /* 16-32 symbols per loop (4-8 symbols per stream) */ endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; ) { HUF_DECODE_SYMBOLX4_2(op1, &bitD1); HUF_DECODE_SYMBOLX4_2(op2, &bitD2); HUF_DECODE_SYMBOLX4_2(op3, &bitD3); HUF_DECODE_SYMBOLX4_2(op4, &bitD4); HUF_DECODE_SYMBOLX4_1(op1, &bitD1); HUF_DECODE_SYMBOLX4_1(op2, &bitD2); HUF_DECODE_SYMBOLX4_1(op3, &bitD3); HUF_DECODE_SYMBOLX4_1(op4, &bitD4); HUF_DECODE_SYMBOLX4_2(op1, &bitD1); HUF_DECODE_SYMBOLX4_2(op2, &bitD2); HUF_DECODE_SYMBOLX4_2(op3, &bitD3); HUF_DECODE_SYMBOLX4_2(op4, &bitD4); HUF_DECODE_SYMBOLX4_0(op1, &bitD1); HUF_DECODE_SYMBOLX4_0(op2, &bitD2); HUF_DECODE_SYMBOLX4_0(op3, &bitD3); HUF_DECODE_SYMBOLX4_0(op4, &bitD4); endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); } /* check corruption */ if (op1 > opStart2) return ERROR(corruption_detected); if (op2 > opStart3) return ERROR(corruption_detected); if (op3 > opStart4) return ERROR(corruption_detected); /* note : op4 supposed already verified within main loop */ /* finish bitStreams one by one */ HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog); HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog); HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog); HUF_decodeStreamX4(op4, &bitD4, oend, dt, dtLog); /* check */ endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); if (!endSignal) return ERROR(corruption_detected); /* decoded size */ return dstSize; } } static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) { HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG); const BYTE* ip = (const BYTE*) cSrc; size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize); if (HUF_isError(hSize)) return hSize; if (hSize >= cSrcSize) return ERROR(srcSize_wrong); ip += hSize; cSrcSize -= hSize; return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable); } /**********************************/ /* quad-symbol decoding */ /**********************************/ typedef struct { BYTE nbBits; BYTE nbBytes; } HUF_DDescX6; typedef union { BYTE byte[4]; U32 sequence; } HUF_DSeqX6; /* recursive, up to level 3; may benefit from