// Use this for initialization
void Start()
{
parent = gameObject.transform.parent.gameObject;
img = GetComponent <Image>();
intro = GameObject.Find("Event Controller").GetComponent <Intro>();
taskCreator = GameObject.Find("Event Controller").GetComponent <TaskCreator>();
gameMan = GameObject.Find("Event Controller").GetComponent <GameManager>();
SetWinType();
if (textFromInspector)
{
for (int ii = 0; ii < textList.Count; ii++)
{
textList[ii] = textList[ii].Replace("NEWLINE", "\n");
}
displayText = gameObject.transform.parent.gameObject.transform.GetChild(0).GetChild(0).GetComponent <Text>();
if (textList[textIndex].Length <= 33)
{
textList[textIndex] += "\n\n";
}
displayText.text = textList[textIndex];
textIndex++;
print(textIndex);
}
print(transform.position);
}
private void StartCreateBtn_Click(object sender, EventArgs e)
{
// Format: 0-Title|1-Mini-Disc(Acceptrance Criteria)|2-Story Points|3-Hours|4-Descriptions
TaskCreator taskCreator = new TaskCreator(_settings);
string clippedTasks = Clipboard.GetText();
List <string> tasks = Regex.Split(clippedTasks, @"\r\n").ToList();
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += (s, env) =>
{
tasks.ForEach(x =>
{
x = x.Trim();
if (!string.IsNullOrEmpty(x) && x.Contains('|'))
{
string[] createStringArr = x.Split('|');
if (createStringArr.Length < 5)
{
MessageBox.Show($"An error has occured: The create-string is in invalid format. create-string: {x}", "Error:", MessageBoxButtons.OK, MessageBoxIcon.Error);
throw new Exception("Invalid create string format!"); // Something is wrong, decided to end the entire app.
}
CreateUserStoryAndTask(taskCreator, createStringArr);
}
});
};
worker.RunWorkerCompleted += (s, env) => { SetStatus("Completed work..."); };
worker.RunWorkerAsync();
}
public void TaskManagerCommitWithoutCommitNeeed()
{
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test-app";
var builder = new StreamBuilder();
builder.Stream <string, string>("topic").To("topic2");
var topology = builder.Build();
var supplier = new SyncKafkaSupplier();
var producer = supplier.GetProducer(config.ToProducerConfig());
var consumer = supplier.GetConsumer(config.ToConsumerConfig(), null);
var taskCreator = new TaskCreator(topology.Builder, config, "thread-0", supplier, producer);
var taskManager = new TaskManager(topology.Builder, taskCreator, supplier.GetAdmin(config.ToAdminConfig("admin")), consumer);
taskManager.CreateTasks(
new List <TopicPartition>
{
new TopicPartition("topic", 0),
new TopicPartition("topic", 1),
new TopicPartition("topic", 2),
new TopicPartition("topic", 3),
});
Assert.AreEqual(4, taskManager.ActiveTasks.Count());
Assert.AreEqual(0, taskManager.CommitAll());
taskManager.Close();
}
private void CreateUserStoryAndTask(TaskCreator taskCreator, string[] createStringArr)
{
TFS_Item userStoryItem = Utilities.DeepClone(_settings.TFSDefaults);
userStoryItem.WorkItemType = WorkItemType.UserStory;
ExtractCommonFields(userStoryItem, createStringArr);
CleanTaskItem(userStoryItem, WorkItemType.UserStory);
string workItemTitle = userStoryItem.Title.Length > 30 ? userStoryItem.Title.Substring(0, 30) : userStoryItem.Title;
SetStatus($"Creating User Story: {workItemTitle}...");
var userStoryItemResult = taskCreator.CreateWorkItem(userStoryItem);
if (userStoryItemResult.Id.GetValueOrDefault() > 0)
{
TFS_Item taskItem = Utilities.DeepClone(_settings.TFSDefaults);
taskItem.WorkItemType = WorkItemType.Task;
taskItem.ParentID = userStoryItemResult.Id.Value.ToString();
ExtractCommonFields(taskItem, createStringArr);
CleanTaskItem(taskItem, WorkItemType.Task);
taskItem.OriginalEstimate = createStringArr[3]; // Hours for the task, used for Original Estimate and Remaining Hours
SetStatus($"Creating Task: {workItemTitle}...");
var taskItemResult = taskCreator.CreateWorkItem(taskItem);
if (userStoryItemResult.Id.GetValueOrDefault() <= 0)
{
MessageBox.Show($"Failed to create task: {taskItem.Title}", "Error:", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public static PlannerTask Create(BehaviorNode node, Agent pAgent)
{
if (ms_factory == null)
{
ms_factory = new Dictionary <Type, TaskCreator>();
Register <Action>((n, a) => new PlannerTaskAction(n, a));
Register <Task>((n, a) => new PlannerTaskTask(n, a));
Register <Method>((n, a) => new PlannerTaskMethod(n, a));
Register <Sequence>((n, a) => new PlannerTaskSequence(n, a));
Register <Selector>((n, a) => new PlannerTaskSelector(n, a));
Register <Parallel>((n, a) => new PlannerTaskParallel(n, a));
Register <ReferencedBehavior>((n, a) => new PlannerTaskReference(n, a));
Register <DecoratorLoop>((n, a) => new PlannerTaskLoop(n, a));
Register <DecoratorIterator>((n, a) => new PlannerTaskIterator(n, a));
}
Type type = node.GetType();
while (!ms_factory.ContainsKey(type))
{
type = type.BaseType;
Debug.Check(type != null);
}
if (ms_factory.ContainsKey(type))
{
TaskCreator c = ms_factory[type];
PlannerTask task = c(node, pAgent);
return(task);
}
return(null);
}
private void Start()
{
gameManager = GameObject.Find("GameManager").GetComponent <GameManager>();
loadedResources = gameManager.GetComponent <LoadedResources>();
taskCreator = gameManager.GetComponent <TaskCreator>();
taskCreator.targets.Add(gameObject); // add ourselves to the list of targets in TaskCreator
}
public IActionResult Index()
{
var bug = TaskCreator.CreateBug();
ViewData["Message"] = "Show default bug info";
return(View(bug));
}
public static Task CreateTask(ServiceChannel channel, MethodCall methodCall, ProxyOperationRuntime operation)
{
if (operation.TaskTResult == ServiceReflector.VoidType)
{
return(TaskCreator.CreateTask(channel, operation, methodCall.Args));
}
return(TaskCreator.CreateGenericTask(channel, operation, methodCall.Args));
}
private void TestCreate()
{
TFS_Item itemToCreate = CreateTestTFSItem(WorkItemType.Task);
TaskCreator taskCreator = new TaskCreator(_settings);
var result = taskCreator.CreateWorkItem(itemToCreate);
Console.WriteLine(result.Id);
}
public static async Task Main(string[] args)
{
List <Task> tasks = new List <Task>();
CancellationTokenSource tokenSource;
CancellationToken token;
try
{
await TaskCreator.CreateTask();
}
catch (System.Threading.Tasks.TaskCanceledException)
{
}
try
{
tokenSource = new CancellationTokenSource(2000);
token = tokenSource.Token;
await TaskCreator.CreateTask(token);
}
catch (System.Threading.Tasks.TaskCanceledException)
{
}
try
{
tokenSource = new CancellationTokenSource(2000);
token = tokenSource.Token;
for (int i = 0; i < 10; i++)
{
tasks.Add(TaskCreator.CreateTask(token));
}
await Task.WhenAll(tasks);
}
catch (AggregateException ae)
{
}
finally
{
tasks.Clear();
}
try
{
tokenSource = new CancellationTokenSource();
token = tokenSource.Token;
for (int i = 0; i < 10; i++)
{
tasks.Add(TaskCreator.CreateTask(token));
}
await Task.WhenAny(tasks);
tokenSource.Cancel();
}
catch (AggregateException ae)
{
}
}
public void TaskManagerAssignedUnknownPartitions()
{
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test-app";
var serdes = new StringSerDes();
var builder = new StreamBuilder();
builder.Stream <string, string>("topic")
.Map((k, v) => KeyValuePair.Create(k.ToUpper(), v.ToUpper()))
.To("topic2");
var topology = builder.Build();
var supplier = new SyncKafkaSupplier();
var producer = supplier.GetProducer(config.ToProducerConfig());
var consumer = supplier.GetConsumer(config.ToConsumerConfig(), null);
var restoreConsumer = supplier.GetRestoreConsumer(config.ToConsumerConfig());
var storeChangelogReader =
new StoreChangelogReader(config, restoreConsumer, "thread-0", new StreamMetricsRegistry());
var taskCreator = new TaskCreator(topology.Builder, config, "thread-0", supplier, producer,
storeChangelogReader, new StreamMetricsRegistry());
var taskManager = new TaskManager(topology.Builder, taskCreator,
supplier.GetAdmin(config.ToAdminConfig("admin")), consumer, storeChangelogReader);
taskManager.CreateTasks(
new List <TopicPartition>
{
new TopicPartition("topic", 0),
new TopicPartition("topic", 1)
});
taskManager.RevokeTasks(
new List <TopicPartition>
{
new TopicPartition("topic", 1)
});
taskManager.CreateTasks(
new List <TopicPartition>
{
new TopicPartition("topic", 0),
new TopicPartition("topic", 1),
new TopicPartition("topic", 2)
});
taskManager.TryToCompleteRestoration();
Assert.AreEqual(3, taskManager.ActiveTasks.Count());
Assert.AreEqual(0, taskManager.RevokedTasks.Count());
taskManager.Close();
}
/// <summary>
/// Der Haupteinstiegspunkt für die Anwendung.
/// </summary>
static void Main(String[] args)
{
_ = GlobalConfiguration.Configuration
.UseColouredConsoleLogProvider()
.UseMemoryStorage();
MemoryStorageOptions options = new MemoryStorageOptions();
// options.JobExpirationCheckInterval = TimeSpan.FromSeconds(30);
// options.FetchNextJobTimeout = TimeSpan.FromSeconds(30);
JobStorage.Current = new MemoryStorage(options);
string baseAddress = "http://localhost:9000/";
WebApp.Start <Startup>(url: baseAddress);
try
{
SettingsFileReader reader = new SettingsFileReader();
var settingsFile = reader.ReadSettingsFile();
Validator.ValidateJsonModel(ref settingsFile);
var armaServer = ArmaServer.GetInstance();
armaServer.SetSettingsFile(settingsFile.settings);
armaServer.SetupServer();
var rcon = RconConnector.GetRconConnector();
rcon.SetSettingsFile(settingsFile.settings);
rcon.OpenConnection();
rcon.StartQueueWorker();
TaskCreator.CreateTasks(settingsFile);
armaServer.StartAll();
while (true)
{
Console.ReadKey();
}
}
catch (SettingsFileReadException e)
{
Console.WriteLine("Error reading the settings file...");
Console.ReadKey();
}
catch (Exception e)
{
Console.WriteLine(e);
Console.ReadKey();
}
}
// Use this for initialization
void Start()
{
gameManager = GameObject.Find("GameManager").GetComponent <GameManager>();
chickenManager = gameManager.gameObject.GetComponent <ChickenManager>();
taskCreator = gameManager.gameObject.GetComponent <TaskCreator>();
loadedResources = gameManager.gameObject.GetComponent <LoadedResources>();
chicken = GetComponent <Chicken>();
ai = GetComponent <AIPath>();
if (age == 0)
{
birthMoment = gameManager.time;
}
}
internal static IThread Create(string threadId, string clientId, InternalTopologyBuilder builder,
StreamMetricsRegistry streamMetricsRegistry, IStreamConfig configuration, IKafkaSupplier kafkaSupplier,
IAdminClient adminClient, int threadInd)
{
string logPrefix = $"stream-thread[{threadId}] ";
var log = Logger.GetLogger(typeof(StreamThread));
var customerID = $"{clientId}-StreamThread-{threadInd}";
IProducer <byte[], byte[]> producer = null;
// TODO : remove this limitations depends version of Kafka Cluster
// Due to limitations outlined in KIP-447 (which KIP-447 overcomes), it is
// currently necessary to use a separate producer per input partition. The
// producerState dictionary is used to keep track of these, and the current
// consumed offset.
// https://cwiki.apache.org/confluence/display/KAFKA/KIP-447%3A+Producer+scalability+for+exactly+once+semantics
// IF Guarantee is AT_LEAST_ONCE, producer is the same of all StreamTasks in this thread,
// ELSE one producer by StreamTask.
if (configuration.Guarantee == ProcessingGuarantee.AT_LEAST_ONCE)
{
log.LogInformation("{LogPrefix}Creating shared producer client", logPrefix);
producer = kafkaSupplier.GetProducer(configuration.ToProducerConfig(GetThreadProducerClientId(threadId)).Wrap(threadId));
}
var restoreConfig = configuration.ToConsumerConfig(GetRestoreConsumerClientId(customerID));
restoreConfig.GroupId = $"{configuration.ApplicationId}-restore-group";
var restoreConsumer = kafkaSupplier.GetRestoreConsumer(restoreConfig);
var storeChangelogReader = new StoreChangelogReader(
configuration,
restoreConsumer,
threadId,
streamMetricsRegistry);
var taskCreator = new TaskCreator(builder, configuration, threadId, kafkaSupplier, producer, storeChangelogReader, streamMetricsRegistry);
var manager = new TaskManager(builder, taskCreator, adminClient, storeChangelogReader);
var listener = new StreamsRebalanceListener(manager);
log.LogInformation("{LogPrefix}Creating consumer client", logPrefix);
var consumer = kafkaSupplier.GetConsumer(configuration.ToConsumerConfig(GetConsumerClientId(customerID)).Wrap(threadId), listener);
manager.Consumer = consumer;
var thread = new StreamThread(threadId, customerID, manager, consumer, builder, storeChangelogReader, streamMetricsRegistry, configuration);
listener.Thread = thread;
return(thread);
}
static void CreateUtils()
{
taskCreator = ScriptableObject.CreateInstance(typeof(TaskCreator)) as TaskCreator;
EditorUtility.SetDirty(taskCreator);
taskSearcher = ScriptableObject.CreateInstance(typeof(TaskSearcher)) as TaskSearcher;
EditorUtility.SetDirty(taskSearcher);
taskManager = ScriptableObject.CreateInstance(typeof(TaskManager)) as TaskManager;
EditorUtility.SetDirty(taskManager);
taskRunner = ScriptableObject.CreateInstance(typeof(TaskRunner)) as TaskRunner;
EditorUtility.SetDirty(taskRunner);
taskSearcher.tasks = new List <Task>();
AssetDatabase.CreateAsset(taskCreator, editorPath + "/TaskCreator.asset");
AssetDatabase.CreateAsset(taskSearcher, editorPath + "/TaskSearcher.asset");
AssetDatabase.CreateAsset(taskManager, editorPath + "/TaskManager.asset");
AssetDatabase.CreateAsset(taskRunner, editorPath + "/TaskRunner.asset");
}
// Use this for initialization
void Start()
{
distMan = GetComponent <DistrictManager>();
taskCreator = GetComponent <TaskCreator>();
arbeauSpawner = GetComponent <ArbeauSpawner>();
closeMap.Add("h1", 0);
closeMap.Add("h2", 1);
closeMap.Add("i1", 2);
closeMap.Add("i2", 3);
if (playGame)
{
StartCoroutine("PlayIntro");
}
//if (playGame) StartCoroutine("StartRound");
//if (playGame) StartRound();
}
static void LoadUtils()
{
if (taskCreator == null)
{
taskCreator = AssetDatabase.LoadAssetAtPath(editorPath + "/TaskCreator.asset", typeof(TaskCreator)) as TaskCreator;
}
if (taskSearcher == null)
{
taskSearcher = AssetDatabase.LoadAssetAtPath(editorPath + "/TaskSearcher.asset", typeof(TaskSearcher)) as TaskSearcher;
}
if (taskManager == null)
{
taskManager = AssetDatabase.LoadAssetAtPath(editorPath + "/TaskManager.asset", typeof(TaskManager)) as TaskManager;
}
if (taskRunner == null)
{
taskRunner = AssetDatabase.LoadAssetAtPath(editorPath + "/TaskRunner.asset", typeof(TaskRunner)) as TaskRunner;
}
}
public StateMachine()
{
this.reader = null;
this.astRoot = null;
if (RemoteTask.FileExist(Settings.TaskFile))
{
this.reader = RemoteTask.GetFile(Settings.TaskFile);
}
else
{
MessageBox.Show(string.Format("Your selected task file wasn't found:\n{0}", Settings.TaskFile));
this.StopAll("");
}
if (this.reader != null)
{
this.pproc = new Preprocessor(this.reader);
this.taskParser = new TaskParser(new StreamReader(this.pproc.ProcessedStream));
this.astRoot = this.taskParser.ParseTask(null);
this.reader.Close();
}
else
{
this.StopAll("TextReader was null. File not found?");
}
this.root = new RootNode();
this.root.AddTask(this.astRoot);
this.root.BindSymbols(); // Just to make it a tad faster
this.taskQueue = new Stack <Task>();
this.activityQueue = new Stack <Activity>();
this.rootTask = TaskCreator.CreateTaskFromNode(this.root, null);
if (this.rootTask == null)
{
this.StopAll("No root task");
}
TaskInfo.Root = this.rootTask;
TaskCreator.CreateTreeFromTasks(this.rootTask);
this.activity = null;
this.taskTimer = new GTimer(300); //300
this.nothingToDoTimer = new GTimer(3 * 1000);
this.tick = new GTimer(100);
}
public TaskRunnerActual(TaskCreator taskCreator,
IDateTimeProvider dateTimeProvider = null)
{
if (dateTimeProvider == null)
{
dateTimeProvider = RecordPoint.Connectors.SDK.Providers.DateTimeProvider.Instance;
}
_taskCreator = taskCreator;
DateTimeProvider = dateTimeProvider;
MockLog = new Mock <ILog>();
Log = MockLog.Object;
Settings = new TaskRunnerBaseSettings()
{
MaxUnhandledExceptions = 2,
DefaultRepeatedTaskFailureTime = TimeSpan.FromSeconds(2),
WaitTimePowBase = 1,
WaitTimeSecondsBase = 1
};
IsKillerException = IsOutOfMemoryException;
}
//metoda odpowiedzialna za uzupełnienie pól informacjami z aktualnego obiektu (zadania)
public TaskEditingWindow(TaskCreator t, MainWindow window)
{
InitializeComponent();
mainWindow = window;
Name.Text = t.Name;
Description.Text = t.Description;
Date.SelectedDate = t.Date;
UpdateTask.Tag = t.Id;
RejectChanges.Tag = t.Id;
//przekazanie właściwego statusu zadania
switch (t.Status)
{
case "Nowy":
Status.SelectedIndex = 0;
break;
case "W realizacji":
Status.SelectedIndex = 1;
break;
case "Zakończony":
Status.SelectedIndex = 2;
break;
}
//przekazanie właściwego priorytetu zadania
switch (t.Priority)
{
case "Niski":
Priority.SelectedIndex = 0;
break;
case "Normalny":
Priority.SelectedIndex = 1;
break;
case "Wysoki":
Priority.SelectedIndex = 2;
break;
}
}
//metoda odpowiedzialna za zapisywanie zmian w obiekcie (zadaniu)
private void SaveChanges(object sender, RoutedEventArgs e)
{
if (Name.Text.Length >= 3 && Description.Text.Length >= 3)
{
TaskCreator toChange = TaskOperator.FindTask((int)((Button)sender).Tag);
toChange.Name = Name.Text;
toChange.Description = Description.Text;
toChange.Priority = Priority.Text;
toChange.Status = Status.Text;
toChange.Date = Date.SelectedDate;
DatabaseOperator databaseOperator = new DatabaseOperator();
databaseOperator.UpdateTask(toChange);
//TODO sprawdzenie czy dane zostały poprawnie zapisane w bazie
Button button = sender as Button;
Popup pop = new Popup();
TextBlock popupText = new TextBlock();
popupText.Text = "Zapisano pomyślnie. Możesz zamknąć okno.";
popupText.Background = Brushes.Green;
popupText.Foreground = Brushes.White;
pop.Child = popupText;
pop.PlacementTarget = button;
pop.IsOpen = true;
mainWindow.FillTasksList(TaskOperator.ListOfTasks);
}
else
{
if (Name.Text.Length < 3)
{
Name.Background = Brushes.LightPink;
}
if (Description.Text.Length < 3)
{
Description.Background = Brushes.LightPink;
}
LengthWarning.Visibility = Visibility.Visible;
}
}
static void Main(string[] args)
{
JaccardTask jcIndex = new JaccardTask();
jcIndex.Run();
TaskCreator task2 = new TaskCreator("L_1 Algoritm", new TableArgs(10, 4, 0, 10), false, "L_1");
task2.Run();
TaskCreator task3 = new TaskCreator("L_2 Algoritm", new TableArgs(10, 2, 0, 10), false, "L_2");
task3.Run();
TaskCreator task4 = new TaskCreator("Cosine Similarity Algoritm", new TableArgs(5, 10, 0, 5), false, "Cosine");
task4.Run();
TaskCreator task5 = new TaskCreator("Pearson Correlation Coefficient Algoritm", new TableArgs(5, 6, 0, 5), false, "Pearson");
task5.Run();
}
//metoda odpowiedzialna za przekazanie danych do klasy zajmującej się obróbką zadań
#region Operacje na zadaniach (związane z bazą danych)
private void SendTask(object sender, RoutedEventArgs e)
{
if (Name.Text.Length >= 3 && Description.Text.Length >= 3)
{
DatabaseOperator databaseOperator = new DatabaseOperator();
TaskCreator task = new TaskCreator(Name.Text, Description.Text, Priority.Text, Date.SelectedDate, Status.Text);
databaseOperator.SendTask(task);
ClearTaskFields();
}
else
{
if (Name.Text.Length < 3)
{
Name.Background = Brushes.LightPink;
}
if (Description.Text.Length < 3)
{
Description.Background = Brushes.LightPink;
}
LengthWarning.Visibility = Visibility.Visible;
}
}
public void TaskCreator_UpdateBothLockedAndName_LockedAndNameIsUpdated()
{
var context = new AlvTimeDbContextBuilder()
.WithTasks()
.WithProjects()
.WithCustomers()
.CreateDbContext();
var storage = new TaskStorage(context);
var creator = new TaskCreator(storage);
creator.UpdateTask(new UpdateTasksDto
{
Id = 1,
Locked = true,
Name = "MyExampleTask"
});
var task = context.Task.FirstOrDefault(x => x.Id == 1);
Assert.Equal("MyExampleTask", task.Name);
Assert.True(task.Locked == true);
}
public void TaskCreator_CreateNewTaskAlreadyExists_NoNewTaskIsCreated()
{
var context = new AlvTimeDbContextBuilder()
.WithTasks()
.WithProjects()
.WithCustomers()
.CreateDbContext();
var storage = new TaskStorage(context);
var creator = new TaskCreator(storage);
var previousNumberOfTasks = context.Task.Count();
creator.CreateTask(new CreateTaskDto
{
Name = "ExampleTask",
Description = "",
Locked = false,
Project = 1
});
Assert.Equal(previousNumberOfTasks, context.Task.Count());
}
public void Start(Call call)
{
tokenSource = new CancellationTokenSource();
while (nextIndex < Tab.Tasks.Count)
{
if (tokenSource.IsCancellationRequested)
{
break;
}
TaskCreator taskCreator = (TaskCreator)Tab.Tasks[nextIndex];
nextIndex++;
//waiting.RemoveAt(0);
//active.Add(listTask);
TaskInstance childTaskInstance = taskCreator.Start(call);
childTaskInstance.Task.Wait(tokenSource.Token);
//childTaskInstance.Task.ContinueWith((taskFinished => TaskFinished(call)));
//listView.SelectedItems = new List<ListItem> { listItemWaiting, listItemLog };
}
}
static void PerformTimerOperation(Object stateInfo, ElapsedEventArgs args)
{
int workThreads = 0, completionThreads = 0;
ThreadPool.GetAvailableThreads(out workThreads, out completionThreads);
if (workThreads == 0)
{
return;
}
using (MongoQueue <TaskMessage> queue = new MongoQueue <TaskMessage>(ConfigurationManager.AppSettings["mongodbqueue"], 100000000))
{
var msg = queue.Receive();
ThreadPool.QueueUserWorkItem(new WaitCallback(x =>
{
if (msg != null)
{
logger.Info("initialize " + msg.ToString());
var task = TaskCreator.CreateInstance(msg);
task.Run();
}
}));
}
}
private void ExecuteLongRunningTask(ISqlConnectionResolver connectionResolver, string taskName, bool shouldFail)
{
// We don't use transaction - if task fails, it remains in the database, marked as incomplete
var taskCreator = new TaskCreator(connectionResolver);
var taskCompleter = new TaskCompleter(connectionResolver);
var task = taskCreator.Create(new TaskCreatorInput
{
Name = taskName
});
// Perfom long-running operations...
if (shouldFail)
{
throw new InvalidOperationException("Task failed.");
}
taskCompleter.Complete(new TaskCompleterInput
{
TaskId = task.TaskId
});
}
internal static IThread Create(string threadId, string clientId, InternalTopologyBuilder builder, IStreamConfig configuration, IKafkaSupplier kafkaSupplier, IAdminClient adminClient, int threadInd)
{
string logPrefix = $"stream-thread[{threadId}] ";
var log = Logger.GetLogger(typeof(StreamThread));
var customerID = $"{clientId}-StreamThread-{threadInd}";
IProducer <byte[], byte[]> producer = null;
// Due to limitations outlined in KIP-447 (which KIP-447 overcomes), it is
// currently necessary to use a separate producer per input partition. The
// producerState dictionary is used to keep track of these, and the current
// consumed offset.
// https://cwiki.apache.org/confluence/display/KAFKA/KIP-447%3A+Producer+scalability+for+exactly+once+semantics
// IF Guarantee is AT_LEAST_ONCE, producer is the same of all StreamTasks in this thread,
// ELSE one producer by StreamTask.
if (configuration.Guarantee == ProcessingGuarantee.AT_LEAST_ONCE)
{
log.Info($"{logPrefix}Creating shared producer client");
producer = kafkaSupplier.GetProducer(configuration.ToProducerConfig(GetThreadProducerClientId(threadId)));
}
var taskCreator = new TaskCreator(builder, configuration, threadId, kafkaSupplier, producer);
var manager = new TaskManager(builder, taskCreator, adminClient);
var listener = new StreamsRebalanceListener(manager);
log.Info($"{logPrefix}Creating consumer client");
var consumer = kafkaSupplier.GetConsumer(configuration.ToConsumerConfig(customerID), listener);
manager.Consumer = consumer;
var thread = new StreamThread(threadId, customerID, manager, consumer, builder, TimeSpan.FromMilliseconds(configuration.PollMs), configuration.CommitIntervalMs);
listener.Thread = thread;
return(thread);
}
public ParTask(NodeTask node)
: base(node)
{
foreach (NodeTask nt in node.SubTasks)
{
Task t = TaskCreator.CreateTaskFromNode(nt, this);
if (t != null)
{
int prio = nt.GetPrio();
List <Task> l;
if (this.orderedChildTasks.TryGetValue(prio, out l))
{
l.Add(t);
}
else
{
l = new List <Task>();
l.Add(t);
this.orderedChildTasks.Add(prio, l);
}
//PPather.WriteLine("Par add prio " + prio + " task " + t);
}
}
}
public void AddInitializableTask(Type messageType, TaskCreator taskType)
{
//initializableTasks.Add(messageType, taskType);
//Notification.Diagnostic(this, "Assigned " + messageType.Name + " with task creator");
}
