public int AddTrialServiceSubscription(string ChargifyID, string CustomerId, int idLead)
{
var response = new BaseResponse();
try
{
var serviceSubscriptionRepository = new ServiceSubscriptionRepository();
var serviceSubscription = new ServiceSubscription()
{
SubscriptionName = "TrialSuscription",
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddMonths(1),
IsActive = true,
idChargifyCustomer = CustomerId,
idChargifySuscription = ChargifyID,
idLead = idLead
};
serviceSubscriptionRepository.Add(serviceSubscription);
serviceSubscriptionRepository.SaveChanges();
return(serviceSubscription.idServiceSubscription);
}
catch (Exception ex)
{
response.Acknowledgment = false;
response.Message = ex.Message;
}
return(0);
}
public async void RegisterService()
{
HttpClient httpClient = new HttpClient();
// For the amount of storage services which should be deployed, register an instance for the discovery
for (int i = 1; i < 3; i++)
{
ServiceSubscription subscription = new ServiceSubscription
{
BaseUrl = $"http://iwi17-storageservice{i}.azurewebsites.net",
HealthCheckRoute = "/swagger",
ServiceName = "StorageService"
};
string jsonSubscription = JsonConvert.SerializeObject(subscription);
try
{
HttpContent content = new StringContent(jsonSubscription, Encoding.UTF8, "application/json");
HttpResponseMessage response = await httpClient.PostAsync("http://iwi17-configurationservice.azurewebsites.net/api/Discovery", content);
}
catch (Exception ex)
{
// TODO Add Logging
}
}
}
public async Task Heartbeat_UpdateServiceSubscription()
{
// Arrange
const uint ttl = 10000;
A.CallTo(() => _compassEnvironment.GetSubscriptionTtl()).Returns(ttl);
var serviceSubscription = new ServiceSubscription
{
ApplicationToken = Guid.NewGuid()
};
var registeredApplication = new RegisteredApplication();
A.CallTo(() => _validateApplicationTokenService.ValidateApplicationTokenAsync(serviceSubscription.ApplicationToken))
.Returns(Task.FromResult(registeredApplication));
A.CallTo(() => _dataStore.GetServiceSubscriptionAsync(serviceSubscription.ApplicationToken))
.Returns(Task.FromResult(serviceSubscription));
// Act
await _sut.Thump(serviceSubscription);
// Assert
A.CallTo(() => _dataStore.UpsertAsync(serviceSubscription, ttl))
.MustHaveHappened(Repeated.Exactly.Once);
}
public async Task Subscription_OverwriteExistingSubscription()
{
// Arrange
var appToken = Guid.NewGuid();
var serviceSubscription = new ServiceSubscription()
{
ApplicationToken = appToken
};
A.CallTo(() => _validateApplicationTokenService.ValidateApplicationTokenAsync(appToken))
.Returns(new RegisteredApplication());
var ttl = (uint)10000;
A.CallTo(() => _compassEnvironment.GetSubscriptionTtl())
.Returns(ttl);
var serviceSubscriptionIdentifier = Guid.NewGuid();
A.CallTo(() => _dataStore.GetServiceSubscriptionAsync(appToken))
.Returns(new ServiceSubscription()
{
Identifier = serviceSubscriptionIdentifier,
ApplicationToken = appToken
});
// Act
await _sut.SubscribeAsync(serviceSubscription);
// Assert
A.CallTo(() => _dataStore.UpsertAsync(A <ServiceSubscription> .That.Matches(arg => arg.Identifier == serviceSubscriptionIdentifier), ttl))
.MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => _dataStore.UpsertAsync(serviceSubscription, ttl))
.MustHaveHappened(Repeated.Exactly.Once);
}
private void btnSave_Click(object sender, EventArgs e)
{
//declare SQL DB context var
SmartSocialdbDataContext smartsocialDB = new SmartSocialdbDataContext();
ServiceSubscription newServiceSubscriptionsRow = new ServiceSubscription();
try
{
//update selected record in ServiceSubscription table
var subscriptionRow = smartsocialDB.ServiceSubscription.GetByKey(int.Parse(txtID.Text));
subscriptionRow.SubscriptionName = txtName.Text;
subscriptionRow.StartDate = startDate.Value;
subscriptionRow.EndDate = endDate.Value;
subscriptionRow.IsActive = isActive.Checked;
smartsocialDB.SubmitChanges();
smartsocialDB.Connection.Close();
//close this window
this.Close();
}
catch (Exception ex)
{
//show any error message returned by the database
MessageBox.Show(ex.Message);
}
}
private void GenerateTimer(ServiceSubscription sub)
{
var interval = TimeSpan.FromMilliseconds(_options.HeartbeatInterval);
_timer = new Timer(async state => await RunHeartbeatAsync((ServiceSubscription)state), sub, interval,
interval);
}
private async Task <Guid> GetIdentifierAsync(ServiceSubscription serviceSubscription)
{
// When saving a service subscription, we must first check to see if one exists already.
// If it does, we need to use the existing documents identifier in order to overwrite it.
var existingSubscription = await _dataStore.GetServiceSubscriptionAsync(serviceSubscription.ApplicationToken);
return(existingSubscription?.Identifier ?? Guid.NewGuid());
}
private async Task <ServiceSubscription> SaveSubscriptionAsync(ServiceSubscription serviceSubscription)
{
serviceSubscription.Identifier = await GetIdentifierAsync(serviceSubscription);
uint subscriptionTtl = _compassEnvironment.GetSubscriptionTtl();
await _dataStore.UpsertAsync(serviceSubscription, subscriptionTtl);
return(serviceSubscription);
}
private async Task SendEvent(ServiceSubscription serviceSubscription, CompassEvent compassEvent)
{
await _sendToEndpointService.SendToEndpointAsync(new List <ServiceSubscription> {
serviceSubscription
},
compassEvent);
await _queueEventService.DeQueueEventAsync(compassEvent);
}
public UR_CB2_SoftGripper(string robot_url, ToolInfo tool_info)
{
_robot_sub = RobotRaconteurNode.s.SubscribeService(robot_url);
_tool_info = tool_info;
this.tool_info = tool_info;
if (tool_info != null)
{
this.device_info = tool_info.device_info;
}
}
public async Task ReplayQueuedEvents(ServiceSubscription serviceSubscription)
{
var queuedEvents = await _dataStore.GetQueuedEventsAsync();
if (ThereAreNoEvents(queuedEvents))
{
return;
}
await ProcessQueuedEvents(serviceSubscription, queuedEvents);
}
private async Task RunHeartbeatAsync(ServiceSubscription sub)
{
try
{
await Shared.CompassRestClient.SendRequestAsync <ServiceSubscription>(new Uri(_options.CompassUri, "heartbeat"), sub);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private async Task <IEnumerable <CompassEvent> > GetEventsToReplay(ServiceSubscription serviceSubscription, QueuedEvents queuedEvents)
{
var registeredApplication =
await _dataStore.GetRegisteredApplicationAsync(serviceSubscription.ApplicationToken);
var eventsToReplay = queuedEvents.Events.Where(
queuedEvent => serviceSubscription.SubscribedEvents.Contains(queuedEvent.EventName) ||
registeredApplication.LastEventsSubscribed.Contains(queuedEvent.EventName));
return(eventsToReplay);
}
private async Task <ServiceSubscription> GetServiceSubscription(ServiceSubscription serviceSubscription)
{
var subscription = await _dataStore.GetServiceSubscriptionAsync(serviceSubscription.ApplicationToken);
if (subscription == null)
{
subscription = serviceSubscription;
subscription.Identifier = Guid.NewGuid();
}
return(subscription);
}
public async Task Thump(ServiceSubscription serviceSubscription)
{
var registeredApplication = await _validateApplicationTokenService.ValidateApplicationTokenAsync(serviceSubscription.ApplicationToken);
registeredApplication.LastSeen = DateTime.UtcNow;
await _dataStore.UpsertAsync(registeredApplication);
var subscription = await GetServiceSubscription(serviceSubscription);
var subscriptionTtl = _compassEnvironment.GetSubscriptionTtl();
await _dataStore.UpsertAsync(subscription, subscriptionTtl);
}
private async Task ProcessQueuedEvents(ServiceSubscription serviceSubscription, QueuedEvents queuedEvents)
{
var eventsToReplay = await GetEventsToReplay(serviceSubscription, queuedEvents);
var parallelRequests = new List <Task>();
foreach (var compassEvent in eventsToReplay)
{
parallelRequests.Add(SendEvent(serviceSubscription, compassEvent));
}
await Task.WhenAll(parallelRequests);
}
public async Task <IActionResult> Post([FromBody] ServiceSubscription value)
{
Service service = new Service
{
ServiceName = value.ServiceName,
BaseUrl = value.BaseUrl,
HealthCheckRoute = value.HealthCheckRoute,
Healthy = false
};
HealthChecker.Instance.Services.Add(service);
return(Ok());
}
public string SubscribeService(ServiceSubscription Subscription)
{
Application[] applications = this.serviceManager.GetApplications();
if (applications.First((a) => a.ID == Subscription.Application.ID) == null)
{
return("0");
}
Subscription.CreationTime = DateTime.Now;
return(this.serviceManager.AddServiceSubscription(Subscription));
}
static void Main(string[] args)
{
var subscription = new ServiceSubscription
{
ApplicationToken = new Guid("e6e749e1-ced6-485d-b359-c58900f5becf"),
ApplicationUri = new Uri("http://loadbalancer:8080/"),
SubscribedEvents = new List <string> {
"AddAccount"
}
};
var compass = new Client(new ConfigOptions(new Uri("http://localhost:5000/")));
var task = compass.SubscribeAsync(subscription).Result;
Thread.Sleep(900000);
}
// Initially subscribe to new service - also calls heartbeat endpoint
public async Task <ServiceSubscription> SubscribeAsync(ServiceSubscription subscription)
{
try
{
return(await _compassSubscribe.ClientSubscribe(subscription));
}
catch (Exception e)
{
Console.WriteLine(e);
// Try to re-subscribe after 30 seconds.
await Task.Delay(30000);
return(await SubscribeAsync(subscription));
}
}
public string UpdateServiceSubscription(ServiceSubscription Subscription)
{
int result = -9;
using (DataModel.DataModelContainer container = new DataModel.DataModelContainer())
{
var model = container.ServiceSubscriptions.FirstOrDefault(ss => ss.ID.ToLower() == Subscription.ID.ToLower());
model.ServiceID = Subscription.Service.ID;
model.Status = Subscription.Status;
model.Subscriber = Subscription.Subscriber;
container.SaveChanges();
}
return(result.ToString());
}
public async Task Heartbeat_ValidateAppToken()
{
// Arrange
var serviceSubscription = new ServiceSubscription
{
ApplicationToken = Guid.NewGuid()
};
A.CallTo(() => _validateApplicationTokenService.ValidateApplicationTokenAsync(serviceSubscription.ApplicationToken))
.Returns(Task.FromResult(new RegisteredApplication()));
// Act
await _sut.Thump(serviceSubscription);
// Assert
A.CallTo(() => _validateApplicationTokenService.ValidateApplicationTokenAsync(serviceSubscription.ApplicationToken))
.MustHaveHappened(Repeated.Exactly.Once);
}
public async Task AddSubscription(string email, string host, int port, int pollingFreaquency, int gracePeriod)
{
ServiceProvider serviceProvider = await serviceProviderRepository.GetByHostAndPort(host, port);
TimeSpan requestedPollingFrequency = GetTimeSpan(pollingFreaquency);
// If service provider is not found add new one
serviceProvider = serviceProvider == null ? new ServiceProvider()
{
Host = host, Port = port, PollingFrequency = requestedPollingFrequency
} : serviceProvider;
// If service provider is existing always update the service provider with the maximum polling freaquency
serviceProvider.PollingFrequency = serviceProvider.PollingFrequency > requestedPollingFrequency? requestedPollingFrequency : serviceProvider.PollingFrequency;
List <ServiceProvider> serviceProvidersToUpdate = new List <ServiceProvider>();
serviceProvidersToUpdate.Add(serviceProvider);
// Update database with service provider details
await serviceProviderRepository.Upsert(serviceProvidersToUpdate);
// Refreash service provider after inserting to map the subscription for user
if (serviceProvider.Id == 0)
{
serviceProvider = await serviceProviderRepository.GetByHostAndPort(host, port);
}
// if service provider not found in the user, update the subscription
User user = await userRepository.GetUserByEmail(email);
if (user.Subscriptions.Where(s => s.Service.Id == serviceProvider.Id).Count() == 0)
{
ServiceSubscription serviceSubscription = new ServiceSubscription()
{
Service = serviceProvider, PollingFrequency = requestedPollingFrequency, GracePeriod = GetTimeSpan(gracePeriod)
};
user.Subscriptions.Add(serviceSubscription);
List <User> usersToUpdate = new List <User>();
usersToUpdate.Add(user);
await userRepository.Upsert(usersToUpdate);
}
}
public async Task <ServiceSubscription> ClientSubscribe(ServiceSubscription serviceSubscription)
{
// if no compass url is set, then we exit.
if (_options.CompassUri == null)
{
throw new NoCompassEndpointSetException();
}
var response =
await CompassRestClient.SendRequestAsync <ServiceSubscription>(
new Uri(_options.CompassUri, "subscribe"), serviceSubscription);
// default timer of 15 seconds
var heartbeat = new CompassHeartbeat(_options);
heartbeat.SendBeatAsync(response);
return(response);
}
public async Task Subscription_ReplayEvents()
{
// Arrange
var serviceSubscription = new ServiceSubscription
{
SubscribedEvents = { "test", "test1" },
ApplicationToken = Guid.NewGuid()
};
A.CallTo(() => _validateApplicationTokenService.ValidateApplicationTokenAsync(serviceSubscription.ApplicationToken))
.Returns(Task.FromResult(new RegisteredApplication()));
// Act
await _sut.SubscribeAsync(serviceSubscription);
// Assert
A.CallTo(() => _replayQueuedEventsService.ReplayQueuedEvents(serviceSubscription))
.MustHaveHappened(Repeated.Exactly.Once);
}
public string AddServiceSubscription(ServiceSubscription Subscription)
{
Subscription.ID = Guid.NewGuid().ToString();
DataModel.ServiceSubscription model = new Model.ServiceSubscription()
{
ID = Subscription.ID,
ServiceID = Subscription.Service.ID,
Subscriber = Subscription.Subscriber,
Status = Subscription.Status,
CreationTime = DateTime.Now
};
using (DataModel.DataModelContainer container = new DataModel.DataModelContainer())
{
model = container.ServiceSubscriptions.Add(model);
container.SaveChanges();
}
return(model.ID.ToString());
}
public async Task <ServiceSubscription> SubscribeAsync(ServiceSubscription serviceSubcription)
{
var registeredApplication =
await _validateApplicationTokenService.ValidateApplicationTokenAsync(
serviceSubcription.ApplicationToken);
var subscription = await SaveSubscriptionAsync(serviceSubcription);
var updateTask = UpdateLastSeenAsync(registeredApplication);
// TODO: Determine if we should replay events...
// TODO: How do we prevent duplicate data while replaying events?
// This could happen if Service A went down, and Service B, listening
// to the same event is still up when Service A comes back up. It will
// receive the the event a second time.
var replayTask = _replayQueuedEventsService.ReplayQueuedEvents(serviceSubcription);
await Task.WhenAll(new List <Task> {
replayTask, updateTask
});
return(subscription);
}
public void loadInitialData(int subscriptionID)
{
//declare SQL DB context var
SmartSocialdbDataContext smartsocialDB = new SmartSocialdbDataContext();
ServiceSubscription newServiceSubscriptionsRow = new ServiceSubscription();
try
{
//load data base on ID passed from main form
txtID.Text = smartsocialDB.ServiceSubscription.GetByKey(subscriptionID).IdServiceSubscription.ToString();
txtName.Text = smartsocialDB.ServiceSubscription.GetByKey(subscriptionID).SubscriptionName;
startDate.Value = (DateTime)smartsocialDB.ServiceSubscription.GetByKey(subscriptionID).StartDate;
endDate.Value = (DateTime)smartsocialDB.ServiceSubscription.GetByKey(subscriptionID).EndDate;
isActive.Checked = (bool)smartsocialDB.ServiceSubscription.GetByKey(subscriptionID).IsActive;
smartsocialDB.Connection.Close();
}
catch (Exception ex)
{
//show any error message returned by the database
MessageBox.Show(ex.Message);
}
}
public async Task Heartbeat([FromBody] ServiceSubscription serviceSubscription)
{
await _heartbeatService.Thump(serviceSubscription);
}
public SubscriptionController()
{
serviceSub = new ServiceSubscription();
}
