protected void TestConcurrentIterationWithDrainer(SubscriptionAction act)
{
IDictionary <string, object> args = new Dictionary <string, object>
{
{ "x-message-ttl", 5000 }
};
string q = Model.QueueDeclare("", false, true, false, args);
Subscription sub = new Subscription(Model, q, false);
PreparedQueue(q);
List <Thread> ts = new List <Thread>();
for (int i = 0; i < 50; i++)
{
SubscriptionDrainer drainer = new SubscriptionDrainer(sub, act);
Thread t = new Thread(drainer.Drain);
ts.Add(t);
t.Start();
}
foreach (Thread t in ts)
{
t.Join();
}
}
public static string ToVerb(this SubscriptionAction action)
{
switch (action)
{
case SubscriptionAction.Activate:
return("activate");
case SubscriptionAction.Subscribe:
return("subscribe");
case SubscriptionAction.Update:
return("update");
case SubscriptionAction.Unsubscribe:
return("unsubscribe from");
case SubscriptionAction.Suspend:
return("suspend");
case SubscriptionAction.DeleteData:
return("delete data for");
case SubscriptionAction.Reinstate:
return("reinstate");
default:
throw new InvalidEnumArgumentException();
}
}
public QLHistoryDataSubscription(string code, DateTime since, HistoryProviderSpan span, SubscriptionAction action = SubscriptionAction.Subscribe)
{
instrument = code;
this.since = new DateTime(since.Ticks, DateTimeKind.Local);
this.span = span;
id = Guid.NewGuid();
this.Action = action;
}
public ShopTools(List <ShopProduct> products)
{
_onSuccessPurchase = new SubscriptionAction();
_onFailedPurchase = new SubscriptionAction();
ConfigurationBuilder builder = ConfigurationBuilder.Instance(StandardPurchasingModule.Instance());
foreach (ShopProduct product in products)
{
builder.AddProduct(product.Id, product.CurrentProductType);
}
}
public DefaultBasicConsumer CreateConsumer(
SubscriptionAction subscriptionAction,
IModel model,
bool modelIsSingleUse,
MessageCallback callback)
{
var consumer = new EasyNetQConsumer(model, queue);
var consumerTag = Guid.NewGuid().ToString();
consumer.ConsumerTag = consumerTag;
subscriptions.Add(consumerTag, new SubscriptionInfo(subscriptionAction, consumer, callback, modelIsSingleUse, model));
return consumer;
}
private void TestSubscriptionAction(SubscriptionAction action)
{
Model.BasicQos(0, 1, false);
string q = Model.QueueDeclare();
Subscription sub = new Subscription(Model, q, false);
Model.BasicPublish("", q, null, enc.GetBytes("a message"));
BasicDeliverEventArgs res = sub.Next();
Assert.IsNotNull(res);
action(sub);
QueueDeclareOk ok = Model.QueueDeclarePassive(q);
Assert.AreEqual(0, ok.MessageCount);
}
public static SubscriptionAction GetSubscriptionAction(this EncompassSubscription configSubscription,
List <SubscriptionSuccessResponse> existingSubscriptions)
{
var performingAction = new SubscriptionAction();
var exsitingResourceSubscription = existingSubscriptions.FirstOrDefault(x => x.Resource.Equals(configSubscription.Resource, StringComparison.CurrentCultureIgnoreCase));
// same resource was subscribied
if (exsitingResourceSubscription != null)
{
// in encompass combination of resourceType and endpoint is unique key
var existingResourceEndpointSubcription = existingSubscriptions.FirstOrDefault(x =>
x.Resource.Equals(configSubscription.Resource, StringComparison.CurrentCultureIgnoreCase) && x.Endpoint.Equals(configSubscription.Endpoint,
StringComparison.CurrentCultureIgnoreCase));
if (existingResourceEndpointSubcription != null)
{
var missingConfigEvent = configSubscription.Events.Except(existingResourceEndpointSubcription.Events).ToList();
if (missingConfigEvent.Count > 0)
{
performingAction.PerformingAction = SubscriptionActionEnum.Update;
performingAction.SubcriptionId = existingResourceEndpointSubcription.SubscriptionId.ToString();
}
}
else
{
// resource is there but we need update endpoint
performingAction.PerformingAction = SubscriptionActionEnum.Update;
performingAction.SubcriptionId = exsitingResourceSubscription.SubscriptionId.ToString();
}
}
else
{
performingAction.PerformingAction = SubscriptionActionEnum.Add;
}
return(performingAction);
}
/// <summary>
/// Gets the configured (P)SUBSCRIBE or (P)UNSUBSCRIBE <see cref="Message"/> for an action.
/// </summary>
internal Message GetMessage(RedisChannel channel, SubscriptionAction action, CommandFlags flags, bool internalCall)
{
var isPattern = channel.IsPatternBased;
var command = action switch
{
SubscriptionAction.Subscribe when isPattern => RedisCommand.PSUBSCRIBE,
SubscriptionAction.Unsubscribe when isPattern => RedisCommand.PUNSUBSCRIBE,
SubscriptionAction.Subscribe when !isPattern => RedisCommand.SUBSCRIBE,
SubscriptionAction.Unsubscribe when !isPattern => RedisCommand.UNSUBSCRIBE,
_ => throw new ArgumentOutOfRangeException("This would be an impressive boolean feat"),
};
// TODO: Consider flags here - we need to pass Fire and Forget, but don't want to intermingle Primary/Replica
var msg = Message.Create(-1, Flags | flags, command, channel);
msg.SetForSubscriptionBridge();
if (internalCall)
{
msg.SetInternalCall();
}
return(msg);
}
public SubscriptionDrainer(Subscription sub, SubscriptionAction op)
{
m_subscription = sub;
PostProcess = op;
}
private void TestSubscriptionAction(SubscriptionAction action)
{
Model.BasicQos(0, 1, false);
string q = Model.QueueDeclare();
Subscription sub = new Subscription(Model, q, false);
Model.BasicPublish("", q, null, enc.GetBytes("a message"));
BasicDeliverEventArgs res = sub.Next();
Assert.IsNotNull(res);
action(sub);
QueueDeclareOk ok = Model.QueueDeclarePassive(q);
Assert.AreEqual(0, ok.MessageCount);
}
protected void TestConcurrentIterationWithDrainer(SubscriptionAction act)
{
IDictionary<string, object> args = new Dictionary<string, object>
{
{"x-message-ttl", 5000}
};
string q = Model.QueueDeclare("", false, true, false, args);
Subscription sub = new Subscription(Model, q, false);
PreparedQueue(q);
List<Thread> ts = new List<Thread>();
for (int i = 0; i < 50; i++)
{
SubscriptionDrainer drainer = new SubscriptionDrainer(sub, act);
Thread t = new Thread(drainer.Drain);
ts.Add(t);
t.Start();
}
foreach(Thread t in ts)
{
t.Join();
}
}
/// <summary>
/// Subscribes or unsubscribes from newspaper.
/// </summary>
public async Task <SubscriptionResultJson> ManageNewspaperSubscription(int newspaperId, SubscriptionAction action)
{
var unsubscribe = action == SubscriptionAction.Unsubscribe;
var result = await TrySubscribeNewspaper(newspaperId, unsubscribe);
if (result.CaptchaRequired)
{
result = await TrySubscribeNewspaper(newspaperId, unsubscribe, await Client.SolveCaptcha());
}
return(result);
}
public DefaultBasicConsumer CreateConsumer(SubscriptionAction subscriptionAction, IModel model, bool modelIsSingleUse, MessageCallback callback)
{
return(new DefaultBasicConsumer());
}
public DefaultBasicConsumer CreateConsumer(SubscriptionAction subscriptionAction, IModel model, bool modelIsSingleUse, MessageCallback callback)
{
return null;
}
public SubscriptionDrainer(Subscription sub, SubscriptionAction op)
{
m_subscription = sub;
PostProcess = op;
}
public SubscriptionInfo(SubscriptionAction subscriptionAction, EasyNetQConsumer consumer, MessageCallback callback, bool modelIsSingleUse, IModel channel)
{
SubscriptionAction = subscriptionAction;
Consumer = consumer;
Callback = callback;
ModelIsSingleUse = modelIsSingleUse;
Channel = channel;
}
public async Task <CommandResponse <bool?> > SetSubverseListChange(DomainReference setReference, string subverse, SubscriptionAction action)
{
DemandAuthentication();
var set = GetSet(setReference.Name, setReference.OwnerName);
if (set == null)
{
return(CommandResponse.FromStatus <bool?>(null, Status.Denied, "Set cannot be found"));
}
//Check Perms
var perms = SetPermission.GetPermissions(set.Map(), User.Identity);
if (!perms.EditList)
{
return(CommandResponse.FromStatus <bool?>(null, Status.Denied, "User not authorized to modify set"));
}
var sub = GetSubverseInfo(subverse);
if (sub == null)
{
return(CommandResponse.FromStatus <bool?>(null, Status.Denied, "Subverse cannot be found"));
}
return(await SetSubverseListChange(set, sub, action).ConfigureAwait(CONSTANTS.AWAIT_CAPTURE_CONTEXT));
}
private async Task <CommandResponse <bool?> > SetSubverseListChange(SubverseSet set, Subverse subverse, SubscriptionAction action)
{
using (var db = new VoatDataContext())
{
CommandResponse <bool?> response = new CommandResponse <bool?>(true, Status.Success, "");
var actionTaken = SubscriptionAction.Toggle;
var setSubverseRecord = db.SubverseSetList.FirstOrDefault(n => n.SubverseSetID == set.ID && n.SubverseID == subverse.ID);
if (setSubverseRecord == null && ((action == SubscriptionAction.Subscribe) || action == SubscriptionAction.Toggle))
{
db.SubverseSetList.Add(new SubverseSetList {
SubverseSetID = set.ID, SubverseID = subverse.ID, CreationDate = CurrentDate
});
actionTaken = SubscriptionAction.Subscribe;
}
else if (setSubverseRecord != null && ((action == SubscriptionAction.Unsubscribe) || action == SubscriptionAction.Toggle))
{
db.SubverseSetList.Remove(setSubverseRecord);
actionTaken = SubscriptionAction.Unsubscribe;
}
await db.SaveChangesAsync().ConfigureAwait(CONSTANTS.AWAIT_CAPTURE_CONTEXT);
//If Subscribe is to a front page, update subscriber count
if (set.Type == (int)SetType.Front && !String.IsNullOrEmpty(set.UserName))
{
await UpdateSubverseSubscriberCount(new DomainReference(DomainType.Subverse, subverse.Name), actionTaken);
}
response.Response = actionTaken == SubscriptionAction.Toggle ? (bool?)null : actionTaken == SubscriptionAction.Subscribe;
return(response);
}
}
public SetSubverseCommand(DomainReference setRef, string subverse, SubscriptionAction action = SubscriptionAction.Toggle)
{
_setRef = setRef;
_action = action;
_subverse = subverse;
}
/// <summary>
/// Event triggered on realtime subscriptions
/// </summary>
public SubscriptionEvent(SubscriptionAction action)
{
Action = action;
}
public SubscribeCommand(DomainReference domainReference, SubscriptionAction action)
{
_action = action;
_domainReference = domainReference;
}
public SubscriptionCommand(DomainType domainType, SubscriptionAction action, string subscriptionItemName)
{
_domainType = domainType;
_action = action;
_name = subscriptionItemName;
}
public async Task <SubscriptionResponse> SendSubscriptionRequestAsync(string telephone, SubscriptionAction action)
{
string strAction = null;
if (action == SubscriptionAction.Subscribe)
{
strAction = "1";
}
else
{
strAction = "0";
}
SubscriptionRequest ideaMartRequest = new SubscriptionRequest()
{
applicationId = AppId,
password = AppPassword,
subscriberId = telephone,
action = strAction,
// version = "1.0"
};
Uri uri = new Uri(GetSubscriptionRequestUrl(IsInProduction));
using (var httpclient = new HttpClient())
{
httpclient.DefaultRequestHeaders.Accept.Clear();
httpclient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
httpclient.DefaultRequestHeaders.Host = uri.Host;
StringContent content = new StringContent(JsonConvert.SerializeObject(ideaMartRequest));
HttpContent httpcontent = content;
httpcontent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
HttpResponseMessage response = await httpclient.PostAsync(uri, httpcontent); //.result<of T>
if (response.IsSuccessStatusCode)
{
string result = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <SubscriptionResponse>(result));
}
var error = new SubscriptionStatusResponse()
{
statusDetail = "ERROR_API"
};
string errorStr = JsonConvert.SerializeObject(error);
return(JsonConvert.DeserializeObject <SubscriptionResponse>(errorStr));
}
}
public DefaultBasicConsumer CreateConsumer(
SubscriptionAction subscriptionAction,
IModel model,
bool modelIsSingleUse,
MessageCallback callback)
{
var consumer = new EasyNetQConsumer(model, queue);
consumer.ConsumerTag = subscriptionAction.Id;
if (subscriptions.ContainsKey(consumer.ConsumerTag))
{
logger.DebugWrite("Removing existing subscription with ConsumerTag: " + consumer.ConsumerTag);
subscriptions.Remove(consumer.ConsumerTag);
}
logger.DebugWrite("Adding subscription with ConsumerTag: " + consumer.ConsumerTag);
subscriptions.Add(consumer.ConsumerTag, new SubscriptionInfo(subscriptionAction, consumer, callback, modelIsSingleUse, model));
return consumer;
}
