public async Task<IToken> GetTokenAsync(IConsumer consumer, IUser user)
{
if (!HasStore)
return await GetTokenAsync(consumer);
var token = Store.Find(user.Name);
if (token == null)
{
token = await GetTokenAsync(consumer);
token.UserId = user.Name;
Store.Add(token);
return token;
}
if (!token.HasExpired)
return token;
var newToken = await RenewTokenAsync(token, consumer);
newToken.UserId = user.Name;
Store.Delete(token);
Store.Add(newToken);
return newToken;
}
public OAuthRequestToken(
string token,
string secret,
IConsumer consumer,
TokenStatus status,
OAuthParameters associatedParameters,
IIdentity authenticatedUser,
string[] roles)
: this()
{
if (string.IsNullOrEmpty(token))
throw new ArgumentException("token must not be null or empty", "token");
if (secret == null)
throw new ArgumentNullException("secret", "secret must not be null");
if (consumer == null)
throw new ArgumentNullException("consumer", "consumer must not be null");
if (roles == null)
throw new ArgumentNullException("roles", "roles must not be null");
this.Token = token;
this.Secret = secret;
this.Status = status;
this.ConsumerKey = consumer.Key;
this.AssociatedParameters = associatedParameters;
this.AuthenticatedUser = authenticatedUser;
this.Roles = roles;
}
private static ConsumedMessage.ConsumingResult BuildFailure(IConsumer consumer,
ConsumedMessageBase message,
Exception exception)
{
consumer.OnError(exception);
return new ConsumedMessage.Failure(message, consumer, exception);
}
public IToken GetToken(IConsumer consumer, IUser user)
{
if (!HasStore)
return GetToken(consumer);
var token = Store.Find(user.Name);
if (token == null)
{
token = GetToken(consumer);
token.UserId = user.Name;
Store.Add(token);
return token;
}
if (!token.HasExpired)
return token;
var newToken = RenewToken(token, consumer);
newToken.UserId = user.Name;
Store.Delete(token);
Store.Add(newToken);
return newToken;
}
public string GetRedirectUri(IConsumer consumer)
{
var redirectUri = RedirectUri;
if (redirectUri != null)
{
var consumerDomain = consumer.Domain.ToLowerInvariant();
var match = Regexs.HTTPUrl.Match(redirectUri);
if (!match.Success)
throw new OAuthException(ErrorCode.InvalidRequest, "The redirect_uri parameter must be an absolute uri");
var domain = match.Groups["domain"].Value.ToLowerInvariant();
var subdomain = match.Groups["subdomain"].Value.ToLowerInvariant();
string redirectDomain;
if (domain.Count(x => x == '.') == 1)
redirectDomain = subdomain + domain;
else
redirectDomain = domain.Trim(new[] { '.' });
if (redirectDomain != consumerDomain)
throw new OAuthException(ErrorCode.InvalidRequest, "The redirect_uri is not authorized");
}
else
redirectUri = consumer.RedirectUrl;
return redirectUri;
}
public IToken GetToken(IConsumer consumer, IUser user)
{
IToken token;
if (HasStore)
{
IToken sessionToken = Store.Find(user.Name);
if (sessionToken == null || sessionToken.HasExpired)
{
sessionToken = GetToken(consumer);
sessionToken.UserId = user.Name;
Store.Add(sessionToken);
}
token = sessionToken;
}
else
{
token = GetToken(consumer);
}
return token;
}
public PublicMvcAuthenticator(string baseUri, string tokenUri, string callBackUrl,
ITokenStore store, IConsumer consumer, ITokenStore requestTokenStore)
: base(baseUri, tokenUri, callBackUrl, store)
{
_consumer = consumer;
_requestTokenStore = requestTokenStore;
}
public void SetUp()
{
eventBus = new EventBus();
internalConsumers = new List<IInternalConsumer>();
createConsumerCalled = 0;
mockBuilder = new MockBuilder();
queue = new Queue(queueName, false);
onMessage = (body, properties, info) => Task.Factory.StartNew(() => { });
persistentConnection = MockRepository.GenerateStub<IPersistentConnection>();
internalConsumerFactory = MockRepository.GenerateStub<IInternalConsumerFactory>();
internalConsumerFactory.Stub(x => x.CreateConsumer()).WhenCalled(x =>
{
var internalConsumer = MockRepository.GenerateStub<IInternalConsumer>();
internalConsumers.Add(internalConsumer);
createConsumerCalled++;
x.ReturnValue = internalConsumer;
}).Repeat.Any();
consumer = new PersistentConsumer(
queue,
onMessage,
persistentConnection,
internalConsumerFactory,
eventBus);
AdditionalSetup();
}
public OAuthAccessToken(
string token,
string secret,
IConsumer consumer,
TokenStatus status,
IRequestToken requestToken)
: this()
{
if (string.IsNullOrEmpty(token))
throw new ArgumentException("token must not be null or empty", "token");
if (secret == null)
throw new ArgumentNullException("secret", "secret must not be null");
if (consumer == null)
throw new ArgumentNullException("consumer", "consumer must not be null");
if (requestToken == null)
throw new ArgumentNullException("requestToken", "requestToken must not be null");
this.Token = token;
this.Secret = secret;
this.Status = status;
this.ConsumerKey = consumer.Key;
this.RequestToken = requestToken;
}
public void can_run_consumer()
{
var lst = ServiceLocator.Current.GetAllInstances<IConsumer>();
_consumer = lst.Find(
s => s.GetType() == typeof (Subscriber<OrderChangeRequestReceivedMessage>));
((Subscriber<OrderChangeRequestReceivedMessage>)_consumer).Consume(buildMsg());
}
public IToken GetToken(IConsumer consumer, IUser user)
{
IToken token;
if (HasStore)
{
token = Store.Find(user.Name);
if (token == null)
{
token = GetToken(consumer);
token.UserId = user.Name;
Store.Add(token);
}
else if (token.HasExpired)
{
IToken renewedToken = RenewToken(token, consumer);
renewedToken.UserId = user.Name;
token = renewedToken;
Store.Add(token);
}
}
else
{
token = GetToken(consumer);
}
return token;
}
public SampleService(IConsumer messageCommandConsumer, IPublisher publisher, TopologyBootstrapper topologyBootstrapper)
{
_messageCommandConsumer = messageCommandConsumer;
_publisher = publisher;
_topologyBootstrapper = topologyBootstrapper;
_stopped = false;
}
/// <summary>
/// Create a simple token received from a service provider.
/// </summary>
/// <param name="type">Token type</param>
/// <param name="token">Token</param>
/// <param name="secret">Secret</param>
/// <param name="consumer">Consumer</param>
public OAuthToken(TokenType type, string token, string secret, IConsumer consumer)
{
this.Type = type;
this.Token = token;
this.Secret = secret;
this.ConsumerKey = consumer.Key;
}
public PartnerMvcAuthenticator(string baseUri, string authorizeUri, string callBackUri,
ITokenStore store, string signingCertificatePath, string certificatePath, string entrustPassword,
IConsumer consumer, ITokenStore requestTokenStore, string signingCertPassword)
: this(baseUri, authorizeUri, callBackUri, store, consumer, requestTokenStore)
{
_signingCertificate = new X509Certificate2(signingCertificatePath, signingCertPassword, X509KeyStorageFlags.MachineKeySet);
_certificate = new X509Certificate2(certificatePath, entrustPassword);
}
public override bool Subscribe(IConsumer consumer, Hashtable parameterMap)
#endif
{
bool success = base.Subscribe(consumer, parameterMap);
if (success)
FireConsumerConnectionEvent(consumer, PipeConnectionEvent.CONSUMER_CONNECT_PULL, parameterMap);
return success;
}
public StreamSubscriber(IModel model, IConsumer consumer, IDispatcher dispatcher)
: base(model)
{
Consumer = consumer;
ConsumerTag = consumer.Id;
Dispatcher = dispatcher;
_isDisposed = false;
}
protected override void RemoveConsumerFromQueue(IConsumer consumer)
{
var s = Dispatcher.GetSubscriber(consumer.Id);
if(s == null)
throw new Exception("Subscriber with Id=" + consumer.Id + " not found");
s.StopConsuming();
}
public PartnerMvcAuthenticator(string baseUri, string authorizeUri, string callBackUri,
ITokenStore store, string signingCertificatePath, string certificatePath, string password,
IConsumer consumer, ITokenStore requestTokenStore)
: this(baseUri, authorizeUri, callBackUri, store, consumer, requestTokenStore)
{
_signingCertificate = new X509Certificate2(signingCertificatePath);
_certificate = new X509Certificate2(certificatePath, password);
}
public PartnerMvcAuthenticator(string baseUri, string authorizeUri, string callBackUri,
ITokenStore store, X509Certificate2 signingCertificate, X509Certificate2 certificate,
IConsumer consumer, ITokenStore requestTokenStore)
: this(baseUri, authorizeUri, callBackUri, store, consumer, requestTokenStore)
{
_signingCertificate = signingCertificate;
_certificate = certificate;
}
/// <summary>
/// Create a new access token
/// </summary>
/// <param name="consumer">The consumer for whom the token is to be created</param>
/// <param name="requestToken">The request token being swapped for this access token</param>
/// <returns>An access token</returns>
public virtual IAccessToken CreateAccessToken(IConsumer consumer, IRequestToken requestToken)
{
return new OAuthAccessToken(
GuidHelper.CreateGuid().ToString("D"),
GuidHelper.CreateGuid().ToString("D"),
consumer,
TokenStatus.Unauthorized,
requestToken);
}
internal FetcherRunnable(string name, IZooKeeperClient zkClient, ConsumerConfig config, Broker broker, List<PartitionTopicInfo> partitionTopicInfos)
{
this.name = name;
this.zkClient = zkClient;
this.config = config;
this.broker = broker;
this.partitionTopicInfos = partitionTopicInfos;
this.simpleConsumer = new Consumer(this.config);
}
public bool RecordNonceAndCheckIsUnique(IConsumer consumer, string nonce)
{
List<string> list = GetNonceListForConsumer(consumer.ConsumerKey);
lock (list)
{
if (list.Contains(nonce)) return false;
list.Add(nonce);
return true;
}
}
public override bool Subscribe(IConsumer consumer, Hashtable parameterMap)
#endif
{
if (!(consumer is IPushableConsumer))
throw new FluorineException("Non-pushable consumer not supported by PushPushPipe");
bool success = base.Subscribe(consumer, parameterMap);
if (success)
FireConsumerConnectionEvent(consumer, PipeConnectionEvent.CONSUMER_CONNECT_PUSH, parameterMap);
return success;
}
public bool RecordNonceAndCheckIsUnique(IConsumer consumer, string nonce)
{
if(nonce==null||consumer.ConsumerKey==null)
return true;
if (!_noncesForConsumer.ContainsKey(consumer.ConsumerKey))
_noncesForConsumer[consumer.ConsumerKey] = new List<string>();
if(_noncesForConsumer[consumer.ConsumerKey].Contains(nonce))
return false;
_noncesForConsumer[consumer.ConsumerKey].Add(nonce);
return true;
}
/// <summary>
/// Create a new request token
/// </summary>
/// <param name="consumer">The consumer for whom the token is to be created</param>
/// <param name="parameters">The parameters that were sent in the request that
/// created this token (both OAuth and additional parameters).</param>
/// <returns>A request token</returns>
public virtual IRequestToken CreateRequestToken(IConsumer consumer, OAuthParameters parameters)
{
return new OAuthRequestToken(
GuidHelper.CreateGuid().ToString("D"),
GuidHelper.CreateGuid().ToString("D"),
consumer,
TokenStatus.Unauthorized,
parameters,
null,
new string[] { });
}
/// <summary>
/// Disconnects consumer from this pipe. Fires pipe connection event.
/// </summary>
/// <param name="consumer">Consumer that should be removed.</param>
/// <returns>true on success, false otherwise.</returns>
public bool Unsubscribe(IConsumer consumer) {
lock (_consumers.SyncRoot) {
if (!_consumers.Contains(consumer))
return false;
_consumers.Remove(consumer);
}
FireConsumerConnectionEvent(consumer, PipeConnectionEvent.CONSUMER_DISCONNECT, null);
if (consumer is IPipeConnectionListener)
_listeners.Remove(consumer);
return true;
}
public Parser(Stream inputStream, XMLConsumer startConsumer, IConsumer destination)
{
m_inputStream = inputStream;
m_documentReader = XmlReader.Create(inputStream);
if (startConsumer == null)
throw new ArgumentNullException("Start consumer is not allowed to be null");
m_startXMLConsumer = startConsumer;
if (m_startXMLConsumer.Context != null)
m_startXMLConsumer.Context.Reader = m_documentReader;
m_consumer = destination;
}
public Task<string> GetSignatureAsync(IConsumer consumer, IUser user, Uri uri, string verb, IConsumer consumer1)
{
var token = new Token
{
ConsumerKey = consumer.ConsumerKey,
ConsumerSecret = consumer.ConsumerSecret,
TokenKey = consumer.ConsumerKey
};
return Task.FromResult(RsaSha1Signer.CreateSignature(_certificate, token, uri, verb));
}
public OAuthService(OAuthEndPoint requestTokenEndPoint, Uri authorizationUrl, OAuthEndPoint accessTokenEndPoint, bool useAuthorizationHeader, string realm, string signatureMethod, string oauthVersion, IConsumer consumer)
{
this.requestTokenEndPoint = requestTokenEndPoint;
this.authorizationUrl = authorizationUrl;
this.accessTokenEndPoint = accessTokenEndPoint;
this.useAuthorizationHeader = useAuthorizationHeader;
this.realm = realm;
this.signatureMethod = signatureMethod;
version = oauthVersion;
this.consumer = consumer;
}
public string GetSignature(IConsumer consumer, IUser user, Uri uri, string verb, IConsumer consumer1)
{
var token = new Token
{
ConsumerKey = consumer.ConsumerKey,
ConsumerSecret = consumer.ConsumerSecret,
TokenKey = consumer.ConsumerKey
};
return new RsaSha1Signer().CreateSignature(_certificate, token, uri, verb);
}
private void DisposeInnerConsumer()
{
_innerConsumer?.Close();
_innerConsumer?.Dispose();
_innerConsumer = null;
}
public XeroCoreApi(string baseUri, ICertificateAuthenticator auth, IConsumer consumer, IUser user,
IJsonObjectMapper readMapper, IXmlObjectMapper writeMapper)
: this(baseUri, auth, consumer, user, readMapper, writeMapper, null)
{
}
public Consumer(IOptions <Configs> config, ICallback processMessage, ILoggerFactory logger, IConsumer <Ignore, string> consumer) : base(config.Value.MicroserviceName, config.Value.ConsumerTopicName, logger)
{
_config = config.Value;
_processMessage = processMessage;
_consumer = consumer;
}
public XeroCoreApi(string baseUri, ICertificateAuthenticator auth, IConsumer consumer, IUser user)
: this(baseUri, auth, consumer, user, null)
{
}
private SizedBufferingConsumer <int> GetConsumer(IConsumer <int> consumer)
{
return(SizedBufferingConsumer <int> .Create(consumer, Utils.IntSizer.Instance, _bufferSize));
}
private void ConsumerClient_OnConsumeError(IConsumer <string, byte[]> consumer, Error e)
{
logger.LogCritical("An error occurred during connect kafka(consumer) -->reason:{0},code:{1}", e.Reason, e.Code.ToString());
}
public abstract T CreateTask(IConsumer <byte[], byte[]> consumer, TaskId id, IEnumerable <TopicPartition> partitions);
public BitmapDecoder(IConsumer <WriteableBitmap> next)
{
this.next = next;
}
public StreamTask(string threadId, TaskId id, TopicPartition partition, ProcessorTopology processorTopology, IConsumer <byte[], byte[]> consumer, IStreamConfig configuration, IKafkaSupplier kafkaSupplier, IProducer <byte[], byte[]> producer)
: base(id, partition, processorTopology, consumer, configuration)
{
this.threadId = threadId;
this.kafkaSupplier = kafkaSupplier;
this.consumedOffsets = new Dictionary <TopicPartition, long>();
// eos enabled
if (producer == null)
{
this.producer = CreateEOSProducer();
InitializeTransaction();
eosEnabled = true;
}
else
{
this.producer = producer;
}
this.collector = new RecordCollector(logPrefix);
collector.Init(ref this.producer);
var sourceTimestampExtractor = (processorTopology.GetSourceProcessor(id.Topic) as ISourceProcessor).Extractor;
Context = new ProcessorContext(configuration, stateMgr).UseRecordCollector(collector);
processor = processorTopology.GetSourceProcessor(partition.Topic);
queue = new RecordQueue <ConsumeResult <byte[], byte[]> >(
100,
logPrefix,
$"record-queue-{id.Topic}-{id.Partition}",
sourceTimestampExtractor == null ? configuration.DefaultTimestampExtractor : sourceTimestampExtractor);
}
public XeroCoreApi(string baseUri, ICertificateAuthenticator auth, IConsumer consumer, IUser user, IRateLimiter rateLimiter)
: this(baseUri, auth, consumer, user, new DefaultMapper(), new DefaultMapper(), rateLimiter)
{
}
public HttpClient(string baseUri, IConsumer consumer, IUser user) : this(baseUri)
{
User = user;
Consumer = consumer;
}
public virtual bool onReceive(MessageEnvelope message, ITransport transport)
{
if (message.Body.isMessageUserBodySelected() && message.Body.MessageUserBody.QueuePath.ToUpper().Equals(this.QueuePath.ToUpper()))
{
lock (consumers)
{
IConsumer <T> consumer = null;
if (consumers.ContainsKey(message.Body.MessageUserBody.ConsumerId))
{
consumer = consumers[message.Body.MessageUserBody.ConsumerId];
}
if (consumer != null)
{
Message <T> msg = new Message <T>();
try
{
msg.fillFromEnvelope(message);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
T result = consumer.onMessage(msg);
if (msg.Mandatory)
{
MessageEnvelope deliveryReportMessage = new MessageEnvelope();
MessageBody deliveryReportBody = new MessageBody();
DeliveryReport deliveryReportData = new DeliveryReport();
deliveryReportMessage.Body = (deliveryReportBody);
deliveryReportMessage.Id = ("/report-for/" + msg.Id);
deliveryReportBody.selectDeliveryReport(deliveryReportData);
deliveryReportData.ConsumerId = (consumer.Id);
deliveryReportData.MessageId = (msg.Id);
deliveryReportData.QueuePath = (this.queuePath);
DeliveredStatus status = new DeliveredStatus();
status.Value = DeliveredStatus.EnumType.delivered;
deliveryReportData.Status = status;
try
{
transport.sendAsync(deliveryReportMessage);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
if (result != null)
{
Message <T> resultMsg = new Message <T>();
resultMsg.Id = msg.Id;
resultMsg.Body = result;
resultMsg.QueuePath = msg.QueuePath;
MessageEnvelope resultMsgEnv;
try
{
resultMsgEnv = resultMsg.createEnvelope();
resultMsgEnv.Body.MessageUserBody.ConsumerId = consumer.Id;
transport.sendAsync(resultMsgEnv);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
}
}
return(true);
}
return(false);
}
public HttpClient(string baseUri, IAuthenticator auth, IConsumer consumer, IUser user)
: this(baseUri, consumer, user)
{
_auth = auth;
}
public virtual void addConsumer(IConsumer <T> consumer)
{
addConsumer(consumer, false);
}
protected BaseConsumer(MqConnection connection, ILogger logger, ISerializer <TMessage> serializer)
{
_currentConsumer = connection.CreateConsumer(logger, serializer, ProcMessage);
}
public static void ErrorHandler <T1, T2>(ILogger logger, IConsumer <T1, T2> producer, Error error)
{
logger.Error("Error in Kafka consumer: {@error}", error);
}
public AustralianPayroll(string baseUri, ICertificateAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper readMapper, IXmlObjectMapper writeMapper)
: base(baseUri, auth, consumer, user, readMapper, writeMapper)
{
Connect();
}
protected override void CleanUp()
{
_consumer.Dispose();
_consumer = null;
}
public virtual void addConsumer(IConsumer <T> consumer, bool persistence)
{
addConsumer(consumer, persistence, null);
}
public XeroCoreApi(string baseUri, ICertificateAuthenticator auth, IConsumer consumer, IUser user, IJsonObjectMapper readMapper, IXmlObjectMapper writeMapper, IRateLimiter rateLimiter)
: base(baseUri, auth, consumer, user, readMapper, writeMapper, rateLimiter)
{
Connect();
}
public static void LogHandler <T1, T2>(ILogger logger, IConsumer <T1, T2> producer, LogMessage logMessage)
{
WriteToLogger(logger, logMessage.Level, $"{logMessage.Name}/{logMessage.Facility}: {logMessage.Message}");
}
public ThreadInfo(IConsumer consumer, IMessage message)
{
Consumer = consumer;
Message = message;
}
// It is strongly recommended to only use this with consumers configured with `enable.auto.offset.store=false`
// since some of the consumes in the batch may succeed prior to encountering an exception, without the caller
// ever having seen the messages.
public static IEnumerable <ConsumeResult <TKey, TVal> > ConsumeBatch <TKey, TVal>(this IConsumer <TKey, TVal> consumer,
TimeSpan maxWaitTime, int maxBatchSize, CancellationToken cts = default(CancellationToken))
{
var waitBudgetRemaining = maxWaitTime;
var deadline = DateTime.UtcNow + waitBudgetRemaining;
var res = new List <ConsumeResult <TKey, TVal> >();
var resSize = 0;
while (waitBudgetRemaining > TimeSpan.Zero && DateTime.UtcNow < deadline && resSize < maxBatchSize)
{
cts.ThrowIfCancellationRequested();
var msg = consumer.Consume(waitBudgetRemaining);
if (msg != null && !msg.IsPartitionEOF)
{
res.Add(msg);
resSize++;
}
waitBudgetRemaining = deadline - DateTime.UtcNow;
}
return(res);
}
private void InitInnerConsumer()
{
_innerConsumer = BuildConfluentConsumer();
Subscribe();
}
/// <summary>
/// Creates a new <see cref="TimedBufferingConsumer{T}"/> that will automatically flush the
/// buffer to the <see cref="IConsumer{T}"/> after the given wait time.
/// </summary>
/// <param name="consumer">The consumer to flush to. Must not be null.</param>
/// <param name="waitTime">The amount of time between automatic flushes.</param>
public static TimedBufferingConsumer <T> Create(IConsumer <T> consumer, TimeSpan waitTime)
=> new TimedBufferingConsumer <T>(consumer, waitTime, new SimpleThreadingTimer());
private Consumer(ConsumerConfig config, string topic, string consumerName)
{
_consumerName = consumerName;
_consumer = new ConsumerBuilder <string, string>(config).Build();
_consumer.Subscribe(topic);
}
/// <summary>
/// Creates a new instance of the <see cref="FetchState"/>-derived
/// object used to store state.
/// </summary>
/// <param name="consumer">The consumer.</param>
/// <param name="context">The producer's context.</param>
/// <returns>A new fetch state instance.</returns>
public override FetchState CreateFetchState(
IConsumer <EncodedImage> consumer,
IProducerContext context)
{
return(new FetchState(consumer, context));
}
public CommonConsumer(IConsumer <T, TB> consumer)
{
_consumer = consumer;
}
public StoppedConsumingEvent(IConsumer consumer)
{
Consumer = consumer;
}
public void StartConsuming(ILoggerConfig config, IConsumer consumer)
{
throw new NotSupportedException("SeriLog not supported in this mode");
}
